medicafe 0.250920.0__tar.gz → 0.251014.0__tar.gz

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediBot/__init__.py

@@ -19,7 +19,7 @@ Smart Import Integration:
         medibot_main = get_components('medibot_main')
 """
 
-__version__ = "0.250920.0"
+__version__ = "0.251014.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediCafe/__init__.py

@@ -27,7 +27,7 @@ Smart Import System:
         api_suite = get_api_access()
 """
 
-__version__ = "0.250920.0"
+__version__ = "0.251014.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediCafe/api_core.py

@@ -6,7 +6,7 @@ Moved from MediLink to centralize shared API operations.
 COMPATIBILITY: Python 3.4.4 and Windows XP compatible
 """
 
-import time, json, os, traceback, sys, requests
+import time, json, os, traceback, sys
 
 # Import centralized logging configuration
 try:
@@ -52,6 +52,16 @@ except ImportError:
             import graphql_utils as MediLink_GraphQL
         except ImportError:
             # Create a dummy module if graphql_utils is not available
+            # BUG (minimally fixed): When graphql_utils is unavailable, DummyGraphQL
+            # lacked OPTUMAI claims inquiry helpers used by get_claim_summary_by_provider.
+            # Minimal fix implemented elsewhere: a capability guard disables OPTUMAI when
+            # these methods are missing so fallback to UHCAPI proceeds without AttributeError.
+            # Recommended next steps:
+            # - Provide explicit no-op stubs here that raise NotImplementedError for clarity.
+            # - Add a small shim that always exposes required methods to decouple import shapes.
+            # - Add a config feature flag to enable/disable OPTUMAI claims inquiry.
+            # - Add environment-based guard (dev/test default off) and metrics counter for use.
+            # - Add unit tests for both capability-present and capability-absent paths.
             class DummyGraphQL:
                 @staticmethod
                 def transform_eligibility_response(response):
@@ -155,8 +165,9 @@ def _get_default_endpoint_payer_ids(endpoint_name):
 
     # OPTUMAI – augmented list (subject to growth once the API adds a payer-list endpoint)
     optumai_payer_ids = [
-        "87726", "06111", "25463", "37602", "39026", "74227", "65088", "81400",
-        "03432", "86050", "86047", "95378", "95467", "LIFE1", "WELM2"
+        # Supported Payer IDs per Optum Real Claims Inquiry (partial swagger)
+        "87726", "25463", "39026", "74227", "LIFE1", "WELM2", "06111",
+        "96385", "37602", "03432", "95467", "86050", "86047", "95378"
     ]
 
     if endpoint_name == 'OPTUMAI':
@@ -689,21 +700,61 @@ class APIClient(BaseAPIClient):
             MediLink_ConfigLoader.log(log_message, level="ERROR")
             raise
 
-def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILITY'):
+def fetch_payer_name_from_api(*args, **kwargs):
     """
-    Fetches the payer name using the provided APIClient instance.
+    Fetch payer name by Payer ID with backward-compatible calling styles.
 
-    :param client: An instance of APIClient
-    :param payer_id: The payer ID to fetch
-    :param primary_endpoint: The primary endpoint to use
-    :return: The payer name if found
+    Supported call signatures:
+    - fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILITY')
+    - fetch_payer_name_from_api(payer_id, config, primary_endpoint='AVAILITY')  # client inferred via factory
+    - fetch_payer_name_from_api(payer_id=payer_id, config=config, client=client, primary_endpoint='AVAILITY')
     """
-    # Ensure client is an instance of APIClient
+    # Normalize arguments
+    client = None
+    payer_id = None
+    config = None
+    primary_endpoint = kwargs.get('primary_endpoint', 'AVAILITY')
+
+    if 'client' in kwargs:
+        client = kwargs.get('client')
+    if 'payer_id' in kwargs:
+        payer_id = kwargs.get('payer_id')
+    if 'config' in kwargs:
+        config = kwargs.get('config')
+
+    if len(args) >= 3 and isinstance(args[0], APIClient):
+        client = args[0]
+        payer_id = args[1]
+        config = args[2]
+        if len(args) >= 4 and 'primary_endpoint' not in kwargs:
+            primary_endpoint = args[3]
+    elif len(args) >= 2 and isinstance(args[0], str) and client is None:
+        # Called as (payer_id, config, [primary_endpoint])
+        payer_id = args[0]
+        config = args[1]
+        if len(args) >= 3 and 'primary_endpoint' not in kwargs:
+            primary_endpoint = args[2]
+    elif len(args) == 1 and isinstance(args[0], APIClient) and (payer_id is None or config is None):
+        # Partial positional with client first, other params via kwargs
+        client = args[0]
+
+    # Acquire client via factory if not provided
+    if client is None:
+        try:
+            from MediCafe.core_utils import get_api_client
+            client = get_api_client()
+            if client is None:
+                client = APIClient()
+        except Exception:
+            client = APIClient()
+
+    # Basic validation
     if not isinstance(client, APIClient):
         error_message = "Invalid client provided. Expected an instance of APIClient."
-        print(error_message)
         MediLink_ConfigLoader.log(error_message, level="ERROR")
-        exit(1)  # Exit the script
+        raise ValueError(error_message)
+    if payer_id is None or config is None:
+        raise ValueError("Missing required arguments: payer_id and config are required")
     
     # TODO: FUTURE IMPLEMENTATION - Remove AVAILITY default when other endpoints have payer-list APIs
     # Currently defaulting to AVAILITY as it's the only endpoint with confirmed payer-list functionality
@@ -750,6 +801,66 @@ def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILI
     # 3. Fall back to endpoints with basic payer lookup if available
     # 4. Use AVAILITY as final fallback
     
+    # If HTTP client is unavailable or endpoints missing, use offline fallback only when allowed (TestMode or env flag)
+    try:
+        http_unavailable = (requests is None)  # type: ignore[name-defined]
+    except Exception:
+        http_unavailable = True
+    # Determine whether offline fallback is permitted
+    # Align with main flow: default True when TestMode key is absent
+    offline_allowed = True
+    try:
+        from MediCafe.core_utils import extract_medilink_config
+        medi_local = extract_medilink_config(config)
+        offline_allowed = bool(medi_local.get('TestMode', True))
+    except Exception:
+        offline_allowed = True
+    try:
+        if os.environ.get('MEDICAFE_OFFLINE_PERMISSIVE', '').strip().lower() in ('1', 'true', 'yes', 'y'):
+            offline_allowed = True
+    except Exception:
+        pass
+
+    if offline_allowed and (http_unavailable or not isinstance(endpoints, dict) or not endpoints):
+        try:
+            # Prefer crosswalk mapping when available
+            try:
+                _, cw = MediLink_ConfigLoader.load_configuration()
+            except Exception:
+                cw = {}
+            payer_mappings = {}
+            try:
+                if isinstance(cw, dict):
+                    payer_mappings = cw.get('payer_mappings', {}) or {}
+            except Exception:
+                payer_mappings = {}
+
+            if payer_id in payer_mappings:
+                resolved = payer_mappings.get(payer_id)
+                MediLink_ConfigLoader.log(
+                    "Using crosswalk mapping for payer {} -> {} (offline)".format(payer_id, resolved),
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+                return resolved
+            # Safe minimal hardcoded map as last resort (test/offline only)
+            fallback_map = {
+                '87726': 'UnitedHealthcare',
+                '06111': 'Aetna',
+                '03432': 'Cigna',
+                '95378': 'Anthem Blue Cross',
+                '95467': 'Blue Shield',
+            }
+            if payer_id in fallback_map:
+                MediLink_ConfigLoader.log(
+                    "Using offline fallback for payer {} -> {}".format(payer_id, fallback_map[payer_id]),
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+                return fallback_map[payer_id]
+        except Exception:
+            pass
+
     # Define endpoint rotation logic with payer-list capability detection
     available_endpoints = []
     
@@ -820,6 +931,47 @@ def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILI
             error_message = "Error calling {0} for Payer ID {1}. Exception: {2}".format(endpoint_name, payer_id, e)
             MediLink_ConfigLoader.log(error_message, level="INFO")
 
+    # Offline/local fallback mapping for common payer IDs when API endpoints are unavailable
+    # Only when offline fallback is permitted
+    if offline_allowed:
+        try:
+            # Prefer crosswalk mapping first
+            try:
+                _, cw = MediLink_ConfigLoader.load_configuration()
+            except Exception:
+                cw = {}
+            payer_mappings = {}
+            try:
+                if isinstance(cw, dict):
+                    payer_mappings = cw.get('payer_mappings', {}) or {}
+            except Exception:
+                payer_mappings = {}
+            if payer_id in payer_mappings:
+                resolved = payer_mappings.get(payer_id)
+                MediLink_ConfigLoader.log(
+                    "Using crosswalk mapping for payer {} -> {} (offline)".format(payer_id, resolved),
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+                return resolved
+            # Minimal fallback map if crosswalk has no mapping (still offline-only)
+            fallback_map = {
+                '87726': 'UnitedHealthcare',
+                '06111': 'Aetna',
+                '03432': 'Cigna',
+                '95378': 'Anthem Blue Cross',
+                '95467': 'Blue Shield',
+            }
+            if payer_id in fallback_map:
+                MediLink_ConfigLoader.log(
+                    "Using offline fallback for payer {} -> {}".format(payer_id, fallback_map[payer_id]),
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+                return fallback_map[payer_id]
+        except Exception:
+            pass
+
     # If all endpoints fail
     final_error_message = "All endpoints exhausted for Payer ID {0}.".format(payer_id)
     print(final_error_message)
@@ -827,30 +979,147 @@ def fetch_payer_name_from_api(client, payer_id, config, primary_endpoint='AVAILI
     raise ValueError(final_error_message)
 
 def get_claim_summary_by_provider(client, tin, first_service_date, last_service_date, payer_id, get_standard_error='false', transaction_id=None, env=None):
-    # VERBOSE LOGGING FOR CLAIM SUMMARY
+    """
+    Unified Claims Inquiry that prefers OPTUMAI GraphQL searchClaim with
+    legacy response mapping, and falls back to legacy UHCAPI REST endpoint
+    to preserve current downstream flows and UI.
+    """
+    # Verbose input logging
     if DEBUG:
-        MediLink_ConfigLoader.log("=" * 80, level="INFO")
-        MediLink_ConfigLoader.log("GET CLAIM SUMMARY BY PROVIDER - VERBOSE DETAILS", level="INFO")
-        MediLink_ConfigLoader.log("=" * 80, level="INFO")
-        MediLink_ConfigLoader.log("TIN: {}".format(tin), level="INFO")
-        MediLink_ConfigLoader.log("First Service Date: {}".format(first_service_date), level="INFO")
-        MediLink_ConfigLoader.log("Last Service Date: {}".format(last_service_date), level="INFO")
-        MediLink_ConfigLoader.log("Payer ID: {}".format(payer_id), level="INFO")
-        MediLink_ConfigLoader.log("Get Standard Error: {}".format(get_standard_error), level="INFO")
-        MediLink_ConfigLoader.log("Transaction ID: {}".format(transaction_id), level="INFO")
-        MediLink_ConfigLoader.log("Environment: {}".format(env), level="INFO")
-        MediLink_ConfigLoader.log("=" * 80, level="INFO")
-    
-    endpoint_name = 'UHCAPI'
+        MediLink_ConfigLoader.log("Claims Inquiry inputs: tin={} start={} end={} payer={} tx={}"
+                                  .format(tin, first_service_date, last_service_date, payer_id, transaction_id),
+                                  level="INFO")
+
     from MediCafe.core_utils import extract_medilink_config
     medi = extract_medilink_config(client.config)
-    url_extension = medi.get('endpoints', {}).get(endpoint_name, {}).get('additional_endpoints', {}).get('claim_summary_by_provider', '')
-    
+
+    # Determine whether OPTUMAI is available/configured
+    endpoints_cfg = medi.get('endpoints', {}) if isinstance(medi, dict) else {}
+    optumai_cfg = endpoints_cfg.get('OPTUMAI', {}) if isinstance(endpoints_cfg, dict) else {}
+    uhcapi_cfg = endpoints_cfg.get('UHCAPI', {}) if isinstance(endpoints_cfg, dict) else {}
+
+    optumai_path = (optumai_cfg.get('additional_endpoints', {}) or {}).get('claims_inquiry')
+    uhc_path = (uhcapi_cfg.get('additional_endpoints', {}) or {}).get('claim_summary_by_provider')
+
+    optumai_api_url = optumai_cfg.get('api_url')
+    use_optumai = bool(optumai_api_url and optumai_path)
+    # Capability guard: disable OPTUMAI if required helpers are unavailable
+    if use_optumai:
+        has_build = hasattr(MediLink_GraphQL, 'build_optumai_claims_inquiry_request')
+        has_transform = hasattr(MediLink_GraphQL, 'transform_claims_inquiry_response_to_legacy')
+        if not (has_build and has_transform):
+            if DEBUG:
+                MediLink_ConfigLoader.log(
+                    "Disabling OPTUMAI claims inquiry: missing GraphQL helpers (build/transform)",
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+            use_optumai = False
+
+    # Validate payer ID list based on endpoint we will attempt
+    # BUG (minimally fixed): Previously a broad except masked invalid payer IDs and config issues.
+    # Minimal fix: narrow exceptions and log a clear warning; proceed to maintain backward compatibility.
+    # Recommended next steps:
+    # - In non-production environments, fail fast on invalid payer IDs.
+    # - Return a structured error object for invalid payers to avoid silent pass-through.
+    # - Add unit tests covering valid/invalid payers and config load failures.
+    try:
+        target_endpoint = 'OPTUMAI' if use_optumai else 'UHCAPI'
+        valid_payers = get_valid_payer_ids_for_endpoint(client, target_endpoint)
+        if payer_id not in valid_payers:
+            raise ValueError("Invalid payer_id: {} for endpoint {}. Must be one of: {}".format(
+                payer_id, target_endpoint, ", ".join(valid_payers)))
+    except (ValueError, KeyError) as e:
+        MediLink_ConfigLoader.log(
+            "Payer validation warning: {}".format(e),
+            level="WARNING",
+            console_output=CONSOLE_LOGGING
+        )
+    except Exception as e:
+        MediLink_ConfigLoader.log(
+            "Payer validation unexpected error: {}".format(e),
+            level="ERROR",
+            console_output=CONSOLE_LOGGING
+        )
+
+    # Build OPTUMAI GraphQL request if configured
+    if use_optumai:
+        try:
+            # Compose headers (providerTaxId is required per Optum Real API)
+            headers = {
+                'Content-Type': 'application/json',
+                'Accept': 'application/json'
+            }
+            # Map billing_provider_tin to providerTaxId
+            provider_tin = medi.get('billing_provider_tin')
+            if provider_tin:
+                headers['providerTaxId'] = str(provider_tin)
+                # correlation id for tracing
+                try:
+                    corr_id = 'mc-ci-{}'.format(int(time.time() * 1000))
+                except Exception:
+                    corr_id = 'mc-ci-{}'.format(int(time.time()))
+                headers['x-optum-consumer-correlation-id'] = corr_id
+
+            # Environment header for sandbox/stage if URL indicates
+            try:
+                api_url_lower = str(optumai_api_url).lower()
+                if any(tag in api_url_lower for tag in ['sandbox', 'stg', 'stage', 'test']):
+                    headers['environment'] = 'sandbox'
+            except Exception:
+                pass
+
+            # Build searchClaimInput per partial swagger
+            search_claim_input = {
+                'payerId': str(payer_id)
+            }
+            # Map dates MM/DD/YYYY -> expected strings for GraphQL (examples show MM/DD/YYYY and also 01/01/2025)
+            if first_service_date:
+                search_claim_input['serviceStartDate'] = first_service_date
+            if last_service_date:
+                search_claim_input['serviceEndDate'] = last_service_date
+
+            # Note: our pagination param is nextPageToken header in swagger; we surface as transaction_id in legacy code
+            # For subsequent pages, pass it in headers; GraphQL spec shows header, but our call builder only handles body.
+            # We'll set header when calling API; the transformer maps nextPageToken -> transactionId for downstream.
+            if transaction_id:
+                headers['nextPageToken'] = transaction_id
+
+            # Build GraphQL body
+            graphql_body = MediLink_GraphQL.build_optumai_claims_inquiry_request(search_claim_input)
+
+            # Make the call
+            response = client.make_api_call('OPTUMAI', 'POST', optumai_path, params=None, data=graphql_body, headers=headers)
+
+            # Transform to legacy format
+            transformed = MediLink_GraphQL.transform_claims_inquiry_response_to_legacy(response)
+            status = transformed.get('statuscode') if isinstance(transformed, dict) else None
+            if status == '200':
+                # Add note so UI can message that Optum Real is active (non-breaking)
+                try:
+                    transformed['data_source'] = 'OPTUMAI'
+                except Exception:
+                    pass
+                return transformed
+            # If not 200, fall through to UHC fallback when permitted
+        except Exception as e:
+            # If capability guard failed upstream for any reason, handle missing attribute gracefully here too
+            if isinstance(e, AttributeError):
+                MediLink_ConfigLoader.log(
+                    "OPTUMAI disabled due to missing GraphQL helpers; falling back to UHCAPI.",
+                    level="WARNING",
+                    console_output=CONSOLE_LOGGING
+                )
+            else:
+                MediLink_ConfigLoader.log("OPTUMAI Claims Inquiry failed: {}".format(e), level="WARNING")
+
+    # Fallback to existing UHC REST behavior to preserve current flows
+    endpoint_name = 'UHCAPI'
+    url_extension = uhc_path or ''
+
     if DEBUG:
-        MediLink_ConfigLoader.log("URL Extension: {}".format(url_extension), level="INFO")
-    
-    # Build headers according to official API documentation
-    # Note: Environment detection is now handled automatically by the API client
+        MediLink_ConfigLoader.log("Falling back to UHCAPI claim_summary_by_provider path: {}".format(url_extension), level="INFO")
+
     headers = {
         'tin': tin,
         'firstServiceDt': first_service_date,
@@ -859,14 +1128,9 @@ def get_claim_summary_by_provider(client, tin, first_service_date, last_service_
         'getStandardError': get_standard_error,
         'Accept': 'application/json'
     }
-    
-    # Add transactionId if provided (for pagination)
     if transaction_id:
         headers['transactionId'] = transaction_id
-    
-    if DEBUG:
-        MediLink_ConfigLoader.log("Headers: {}".format(json.dumps(headers, indent=2)), level="INFO")
-    
+
     return client.make_api_call(endpoint_name, 'GET', url_extension, params=None, data=None, headers=headers)
 
 def get_eligibility(client, payer_id, provider_last_name, search_option, date_of_birth, member_id, npi):

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediCafe/deductible_utils.py

@@ -612,7 +612,8 @@ def extract_super_connector_insurance_info(eligibility_data):
             if insurance_info:
                 return {
                     'insuranceType': insurance_info.get("planTypeDescription", ""),
-                    'insuranceTypeCode': insurance_info.get("productServiceCode", ""),
+                    # Prefer new insuranceTypeCode when available; fallback to productServiceCode
+                    'insuranceTypeCode': insurance_info.get("insuranceTypeCode") or insurance_info.get("productServiceCode", ""),
                     'memberId': insurance_info.get("memberId", ""),
                     'payerId': insurance_info.get("payerId", "")
                 }
@@ -634,7 +635,8 @@ def extract_super_connector_insurance_info(eligibility_data):
                             
                             return {
                                 'insuranceType': insurance_type,
-                                'insuranceTypeCode': detail.get("productServiceCode", ""),
+                                # Prefer insuranceTypeCode if present in extensions; fallback to productServiceCode
+                                'insuranceTypeCode': detail.get("insuranceTypeCode") or detail.get("productServiceCode", ""),
                                 'memberId': detail.get("memberId", ""),
                                 'payerId': detail.get("payerId", "")
                             }
@@ -656,8 +658,10 @@ def extract_super_connector_insurance_info(eligibility_data):
         elif "POS" in insurance_type:
             insurance_type = "Point of Service (POS)"
     
-    # Get insurance type code from multiple possible locations
-    insurance_type_code = eligibility_data.get("productServiceCode", "")
+    # Get insurance type code from multiple possible locations (prefer insuranceTypeCode)
+    insurance_type_code = eligibility_data.get("insuranceTypeCode", "")
+    if not insurance_type_code:
+        insurance_type_code = eligibility_data.get("productServiceCode", "")
     if not insurance_type_code:
         # Try to get from coverageTypes
         coverage_types = eligibility_data.get("coverageTypes", [])
@@ -767,7 +771,8 @@ def convert_eligibility_to_enhanced_format(data, dob, member_id, patient_id="",
                 'service_date_display': service_date,
                 'service_date_sort': datetime.min,  # Will be enhanced later
                 'status': 'Processed',
-                'insurance_type': insurance_info['insuranceType'],
+                # Prefer insurance type code over description for downstream validation/UI
+                'insurance_type': insurance_info.get('insuranceTypeCode') or insurance_info.get('insuranceType', ''),
                 'policy_status': policy_status,
                 'remaining_amount': remaining_amount,
                 'data_source': 'Legacy',
@@ -803,7 +808,8 @@ def convert_eligibility_to_enhanced_format(data, dob, member_id, patient_id="",
             'service_date_display': service_date,
             'service_date_sort': datetime.min,  # Will be enhanced later
             'status': 'Processed',
-            'insurance_type': insurance_info['insuranceType'],
+            # Prefer insurance type code over description for downstream validation/UI
+            'insurance_type': insurance_info.get('insuranceTypeCode') or insurance_info.get('insuranceType', ''),
             'policy_status': policy_status,
             'remaining_amount': remaining_amount,
             'data_source': 'OptumAI',
@@ -975,7 +981,13 @@ def merge_responses(optumai_data, legacy_data, dob, member_id):
                         merged['patient_name'] = "{} {}".format(selected.get('firstName', ''), selected.get('lastName', '')).strip()
                         merged['dob'] = selected.get('dateOfBirth', dob)
                         merged['member_id'] = selected.get('memberId', member_id)
-                        merged['insurance_type'] = selected.get('insuranceType', selected.get('coverageType', ''))
+                        # Prefer insurance type code from extensions when available
+                        merged['insurance_type'] = (
+                            selected.get('insuranceTypeCode') or
+                            selected.get('productServiceCode') or
+                            selected.get('insuranceType') or
+                            selected.get('coverageType', '')
+                        )
                         merged['policy_status'] = selected.get('policyStatus', 'Active')
                         merged['payer_id'] = selected.get('payerId', '')
                         # Extract deductible from plan levels if available
@@ -1008,8 +1020,8 @@ def merge_responses(optumai_data, legacy_data, dob, member_id):
         merged['remaining_amount'] = extract_super_connector_remaining_amount(primary)
         merged['policy_status'] = primary.get('policyStatus', '')
         
-        # OptumAI doesn't have insurance_type yet, so we'll backfill from Legacy
-        merged['insurance_type'] = ''
+        # Prefer insurance type code directly from OptumAI response
+        merged['insurance_type'] = primary.get('insuranceTypeCode') or primary.get('productServiceCode', '')
         merged['data_source'] = 'OptumAI'
         
     elif is_legacy_response_format(primary) and primary:

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediCafe/graphql_utils.py

@@ -218,6 +218,56 @@ class GraphQLQueryBuilder:
             }
         }
 
+    # ------------------------------------------------------------------
+    # OPTUMAI Claims Inquiry (Real Claim Inquiry) - minimal searchClaim
+    # ------------------------------------------------------------------
+    @staticmethod
+    def get_optumai_claims_inquiry_query():
+        """
+        Returns a minimal GraphQL query for searchClaim that includes fields
+        necessary to map into the existing legacy claims summary structure
+        (memberInfo, claimSummary, crosswalk data).
+        """
+        return (
+            "query searchClaim($searchClaimInput: SearchClaimInput!) {\n"
+            "  searchClaimResponse(input: $searchClaimInput) {\n"
+            "    claims {\n"
+            "      claimNumber\n"
+            "      claimStatus\n"
+            "      member { firstName lastName }\n"
+            "      claimEvents { processedDate serviceStartDate }\n"
+            "      claimLevelTotalAmount {\n"
+            "        totalBilledChargeAmount\n"
+            "        totalAllowedAmount\n"
+            "        totalPaidAmount\n"
+            "        totalPatientResponsibilityAmount\n"
+            "      }\n"
+            "      claimStatusCrosswalkData {\n"
+            "        claim507Code claim507CodeDesc claim508Code claim508CodeDesc adjudicatedClaimSuffixCode\n"
+            "      }\n"
+            "    }\n"
+            "    pagination { hasMoreRecords nextPageToken }\n"
+            "  }\n"
+            "}"
+        )
+
+    @staticmethod
+    def build_optumai_claims_inquiry_request(search_claim_input):
+        """
+        Build the GraphQL request body for searchClaim.
+
+        Args:
+            search_claim_input: dict with keys matching SearchClaimInput (e.g.,
+              payerId (required), serviceStartDate, serviceEndDate, claimNumber, etc.)
+        """
+        return {
+            "query": GraphQLQueryBuilder.get_optumai_claims_inquiry_query(),
+            "operationName": "searchClaim",
+            "variables": {
+                "searchClaimInput": search_claim_input or {}
+            }
+        }
+
 class GraphQLResponseTransformer:
     """Transforms GraphQL responses to match REST API format"""
     
@@ -331,7 +381,10 @@ class GraphQLResponseTransformer:
                     'productCode': insurance_info.get('productCode'),
                     'lineOfBusiness': insurance_info.get('lineOfBusiness'),
                     'lineOfBusinessCode': insurance_info.get('lineOfBusinessCode'),
-                    'coverageTypes': insurance_info.get('coverageTypes', [])
+                    'coverageTypes': insurance_info.get('coverageTypes', []),
+                    # Expose insurance type fields for downstream logic/UI
+                    'insuranceTypeCode': insurance_info.get('insuranceTypeCode'),
+                    'insuranceType': insurance_info.get('insuranceType')
                 })
             
             # Safely extract associated IDs
@@ -480,6 +533,87 @@ class GraphQLResponseTransformer:
                 'rawGraphQLResponse': graphql_response
             }
 
+    @staticmethod
+    def transform_claims_inquiry_response_to_legacy(graphql_response):
+        """
+        Transform OPTUMAI searchClaim GraphQL response into the legacy
+        claims summary format expected by downstream code (e.g.,
+        MediLink_ClaimStatus.extract_claim_data).
+        """
+        try:
+            # Handle GraphQL errors
+            if isinstance(graphql_response, dict) and 'errors' in graphql_response:
+                first_err = graphql_response['errors'][0] if graphql_response['errors'] else {}
+                code = (first_err.get('extensions', {}) or {}).get('code') or first_err.get('code') or 'GRAPHQL_ERROR'
+                msg = first_err.get('message') or first_err.get('description') or 'GraphQL error'
+                status = '401' if 'AUTH' in str(code).upper() else '500'
+                return {
+                    'statuscode': status,
+                    'message': '{}: {}'.format(code, msg),
+                    'rawGraphQLResponse': graphql_response
+                }
+
+            data = (graphql_response or {}).get('data') or {}
+            search_resp = data.get('searchClaimResponse') or {}
+            claims = search_resp.get('claims') or []
+            pagination = search_resp.get('pagination') or {}
+
+            legacy_claims = []
+            for c in claims:
+                member = c.get('member') or {}
+                events = c.get('claimEvents') or {}
+                totals = c.get('claimLevelTotalAmount') or {}
+                xwalk_list = c.get('claimStatusCrosswalkData') or []
+
+                # Map crosswalk to legacy keys list
+                legacy_xwalk = []
+                for x in xwalk_list:
+                    legacy_xwalk.append({
+                        'clm507Cd': x.get('claim507Code'),
+                        'clm507CdDesc': x.get('claim507CodeDesc'),
+                        'clm508Cd': x.get('claim508Code'),
+                        'clm508CdDesc': x.get('claim508CodeDesc'),
+                        'clmIcnSufxCd': x.get('adjudicatedClaimSuffixCode')
+                    })
+
+                legacy_claims.append({
+                    'claimNumber': c.get('claimNumber'),
+                    'claimStatus': c.get('claimStatus'),
+                    'memberInfo': {
+                        'ptntFn': member.get('firstName'),
+                        'ptntLn': member.get('lastName')
+                    },
+                    'claimSummary': {
+                        'processedDt': events.get('processedDate') or '',
+                        'firstSrvcDt': events.get('serviceStartDate') or '',
+                        'totalChargedAmt': (totals.get('totalBilledChargeAmount') or ''),
+                        'totalAllowdAmt': (totals.get('totalAllowedAmount') or ''),
+                        'totalPaidAmt': (totals.get('totalPaidAmount') or ''),
+                        'totalPtntRespAmt': (totals.get('totalPatientResponsibilityAmount') or ''),
+                        'clmXWalkData': legacy_xwalk
+                    }
+                })
+
+            next_token = pagination.get('nextPageToken')
+            has_more = bool(pagination.get('hasMoreRecords'))
+
+            transformed = {
+                'statuscode': '200',
+                'message': 'Claims found' if legacy_claims else 'No claims found',
+                'claims': legacy_claims,
+                # Maintain legacy pagination signaling by mapping to 'transactionId'
+                'transactionId': next_token if has_more else None,
+                'rawGraphQLResponse': graphql_response
+            }
+            return transformed
+        except Exception as e:
+            print("Error transforming Claims Inquiry response: {}".format(str(e)))
+            return {
+                'statuscode': '500',
+                'message': 'Error processing Claims Inquiry response: {}'.format(str(e)),
+                'rawGraphQLResponse': graphql_response
+            }
+
 # Convenience functions for easy access
 
 def get_eligibility_query():
@@ -502,10 +636,18 @@ def build_optumai_enriched_request(variables):
     """Build enriched GraphQL request body for OPTUMAI"""
     return GraphQLQueryBuilder.build_optumai_enriched_request(variables)
 
+def build_optumai_claims_inquiry_request(search_claim_input):
+    """Build GraphQL request body for OPTUMAI searchClaim"""
+    return GraphQLQueryBuilder.build_optumai_claims_inquiry_request(search_claim_input)
+
 def transform_eligibility_response(graphql_response):
     """Transform GraphQL eligibility response to REST format"""
     return GraphQLResponseTransformer.transform_eligibility_response(graphql_response)
 
+def transform_claims_inquiry_response_to_legacy(graphql_response):
+    """Transform OPTUMAI searchClaim response to legacy claims summary format"""
+    return GraphQLResponseTransformer.transform_claims_inquiry_response_to_legacy(graphql_response)
+
 def get_sample_eligibility_request():
     """Get the sample GraphQL request from swagger documentation"""
     return GraphQLQueryBuilder.get_sample_eligibility_request()

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediLink/MediLink_837p_encoder_library.py

@@ -87,21 +87,24 @@ except (ImportError, SystemError):
     except ImportError:
         MediLink_UI = None
 
-# Import MediBot crosswalk utilities with fallback - using dynamic imports to avoid circular dependencies
-try:
-    import MediBot_Crosswalk_Utils
-    update_crosswalk_with_corrected_payer_id = MediBot_Crosswalk_Utils.update_crosswalk_with_corrected_payer_id
-    update_crosswalk_with_new_payer_id = MediBot_Crosswalk_Utils.update_crosswalk_with_new_payer_id
-except ImportError:
-    # Fallback to main library if utility import fails
-    try:
-        import MediBot_Crosswalk_Library
-        update_crosswalk_with_corrected_payer_id = MediBot_Crosswalk_Library.update_crosswalk_with_corrected_payer_id
-        update_crosswalk_with_new_payer_id = MediBot_Crosswalk_Library.update_crosswalk_with_new_payer_id
-    except (ImportError, AttributeError):
-        # If functions are not available, set to None for graceful handling
-        update_crosswalk_with_corrected_payer_id = None
-        update_crosswalk_with_new_payer_id = None
+# Import MediBot crosswalk utilities via centralized import helpers
+from MediCafe.core_utils import import_medibot_module
+
+# Resolve required functions directly at import-time using centralized helper (Py 3.4.4 friendly)
+update_crosswalk_with_new_payer_id = (
+    import_medibot_module('MediBot_Crosswalk_Utils', 'update_crosswalk_with_new_payer_id') or
+    import_medibot_module('MediBot_Crosswalk_Library', 'update_crosswalk_with_new_payer_id')
+)
+
+update_crosswalk_with_corrected_payer_id = (
+    import_medibot_module('MediBot_Crosswalk_Utils', 'update_crosswalk_with_corrected_payer_id') or
+    import_medibot_module('MediBot_Crosswalk_Library', 'update_crosswalk_with_corrected_payer_id')
+)
+
+if not callable(update_crosswalk_with_new_payer_id):
+    raise RuntimeError("Crosswalk update function not available (new payer id). Ensure MediBot_Crosswalk_Utils or MediBot_Crosswalk_Library is importable.")
+if not callable(update_crosswalk_with_corrected_payer_id):
+    raise RuntimeError("Crosswalk update function not available (corrected payer id). Ensure MediBot_Crosswalk_Utils or MediBot_Crosswalk_Library is importable.")
 
 # Import enhanced insurance selection with fallback
 # XP/Python34 Compatibility: Enhanced error handling with verbose output

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediLink/MediLink_ClaimStatus.py

@@ -263,6 +263,17 @@ def process_claims_with_pagination(client, billing_provider_tin, start_date_str,
                 client, billing_provider_tin, start_date_str, end_date_str, 
                 payer_id=payer_id, transaction_id=transaction_id
             )
+            # Informational notice if new OPTUM Real endpoint is being used
+            try:
+                if isinstance(claim_summary, dict) and claim_summary.get('data_source') == 'OPTUMAI':
+                    MediLink_ConfigLoader.log(
+                        "Claims Inquiry via Optum Real endpoint (OPTUMAI) with legacy-compatible output.",
+                        level="INFO"
+                    )
+                    if DEBUG:
+                        print("[Info] Using Optum Real Claims Inquiry for payer {}".format(payer_id))
+            except Exception:
+                pass
             
             # Extract claims from this page
             claims = claim_summary.get('claims', [])

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediLink/MediLink_Deductible.py

@@ -1027,7 +1027,7 @@ if __name__ == "__main__":
             output_file_path = os.path.join(os.getenv('TEMP'), 'eligibility_report.txt')
             with open(output_file_path, 'w') as output_file:
                 table_header = "{:<20} | {:<10} | {:<40} | {:<5} | {:<14} | {:<14}".format(
-                    "Patient Name", "DOB", "Insurance Type", "PayID", "Policy Status", "Remaining Amt")
+                    "Patient Name", "DOB", "Insurance Type Code", "PayID", "Policy Status", "Remaining Amt")
                 output_file.write(table_header + "\n")
                 output_file.write("-" * len(table_header) + "\n")
                 

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediLink/MediLink_Deductible_Validator.py

@@ -72,7 +72,8 @@ def extract_legacy_values_for_comparison(legacy_data):
         
         # Extract insurance info
         insurance_info = policy.get("insuranceInfo", {})
-        comparison_values["insurance_type"] = insurance_info.get("insuranceType", "")
+        # Prefer standardized insuranceTypeCode for comparisons; keep description as secondary
+        comparison_values["insurance_type"] = insurance_info.get("insuranceTypeCode", "") or insurance_info.get("insuranceType", "")
         comparison_values["insurance_typeCode"] = insurance_info.get("insuranceTypeCode", "")
         comparison_values["insurance_memberId"] = insurance_info.get("memberId", "")
         comparison_values["insurance_payerId"] = insurance_info.get("payerId", "")

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediLink/MediLink_Display_Utils.py

@@ -66,10 +66,11 @@ def display_file_summary(index, summary):
                          summary.get('user_preferred_endpoint') or 
                          summary.get('suggested_endpoint', 'AVAILITY'))
 
-    # Format insurance type for display - handle both 2 and 3 character codes
+    # Format insurance type for display - prioritize code (SBR09/insuranceTypeCode)
     if insurance_type and len(insurance_type) <= 3:
         insurance_display = insurance_type
     else:
+        # If description was provided instead of code, truncate respectfully
         insurance_display = insurance_type[:3] if insurance_type else '--'
 
     # Shorten source for compact display
@@ -384,7 +385,7 @@ def _display_table_header(col_widths, context):
             "Member ID", col_widths['member_id'],
             "Payer ID", col_widths['payer_id'],
             "Service Date", col_widths['service_date'],
-            "Insurance Type", col_widths['insurance_type'],
+            "Insurance Type Code", col_widths['insurance_type'],
             "Policy Status", col_widths['policy_status'],
             "Remaining Amt", col_widths['remaining_amount']
         )

{medicafe-0.250920.0 → medicafe-0.251014.0}/MediLink/__init__.py

@@ -22,7 +22,7 @@ Smart Import Integration:
         datamgmt = get_components('medilink_datamgmt')
 """
 
-__version__ = "0.250920.0"
+__version__ = "0.251014.0"
 __author__ = "Daniel Vidaud"
 __email__ = "daniel@personalizedtransformation.com"
 

{medicafe-0.250920.0/medicafe.egg-info → medicafe-0.251014.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250920.0
+Version: 0.251014.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2/MediCafe
 Author: Daniel Vidaud

{medicafe-0.250920.0 → medicafe-0.251014.0/medicafe.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: medicafe
-Version: 0.250920.0
+Version: 0.251014.0
 Summary: MediCafe
 Home-page: https://github.com/katanada2/MediCafe
 Author: Daniel Vidaud

{medicafe-0.250920.0 → medicafe-0.251014.0}/setup.py

@@ -54,7 +54,7 @@ if long_description_text is None:
 
 setup(
     name='medicafe',
-    version="0.250920.0",
+    version="0.251014.0",
     description='MediCafe',
     long_description=long_description_text,
     long_description_content_type='text/markdown',