sea-dev 1.0.0

package/libs/core/src/chat/tools/credit-agent.ts

@@ -0,0 +1,1383 @@
+/**
+ * Deep Dive Agent
+ * Specializes in sandbox code execution and exploratory analysis
+ */
+
+import type { VercelConfig } from "@sea/config/vercel";
+import type { Member } from "@sea/db/types";
+import { Sandbox } from "@vercel/sandbox";
+import { tool, ToolLoopAgent, type LanguageModel } from "ai";
+import { z } from "zod/v4";
+import { createArtifact, updateAgentMemory } from "./agent";
+import { fetchSubmissionAgent } from "./submission";
+
+const creditScoringModelCode = `
+"""
+Credit Scoring Model - Python Implementation
+
+Extracted from Excel workbook "Credit Scoring Model - example.xlsm"
+Validated against spreadsheet calculations.
+
+Usage:
+    from credit_scoring_model import CreditScoringPipeline, FinancialYear, QualitativeInputs
+
+    years_data = [FinancialYear(...), ...]
+    qualitative = QualitativeInputs(...)
+
+    pipeline = CreditScoringPipeline(years_data, qualitative)
+    result = pipeline.run()
+
+    print(f"Score: {result.score_percentage:.1%}")
+    print(f"Tier: {result.tier}")
+"""
+
+from dataclasses import dataclass, field
+from typing import Optional, Dict, List, Tuple, Callable
+from enum import Enum
+import numpy as np
+
+
+# =============================================================================
+# 1. SCORING CONFIGURATION
+# =============================================================================
+# Edit this section to add/modify metrics and benchmarks.
+# Each metric needs:
+#   - benchmark: threshold value
+#   - higher_is_better: True if higher values are better
+#   - category: for grouping in reports
+#   - Optional: years (specific years to average), use_latest (use only latest year)
+
+METRIC_CONFIG = {
+    # -------------------------------------------------------------------------
+    # PROFITABILITY
+    # -------------------------------------------------------------------------
+    'revenue_cagr': {
+        'benchmark': 0.05,
+        'higher_is_better': True,
+        'use_latest': True,
+        'category': 'profitability',
+        'description': 'Revenue CAGR (4-year)',
+    },
+    'gross_profit_margin': {
+        'benchmark': 0.05,
+        'higher_is_better': True,
+        'category': 'profitability',
+        'description': 'Gross Profit / Revenue',
+    },
+    'operating_profit_margin': {
+        'benchmark': 0.03,
+        'higher_is_better': True,
+        'category': 'profitability',
+        'description': 'Operating Profit / Revenue',
+    },
+    'net_profit_margin': {
+        'benchmark': 0.02,
+        'higher_is_better': True,
+        'category': 'profitability',
+        'description': 'Net Profit / Revenue',
+    },
+    'return_on_assets': {
+        'benchmark': 0.07,
+        'higher_is_better': True,
+        'category': 'profitability',
+        'description': 'Net Profit / Total Assets',
+    },
+    'return_on_equity': {
+        'benchmark': 0.13,
+        'higher_is_better': True,
+        'category': 'profitability',
+        'description': 'Net Profit / Equity',
+    },
+
+    # -------------------------------------------------------------------------
+    # LIQUIDITY
+    # -------------------------------------------------------------------------
+    'current_ratio': {
+        'benchmark': 1.2,
+        'higher_is_better': True,
+        'category': 'liquidity',
+        'description': 'Current Assets / Current Liabilities',
+    },
+    'quick_ratio': {
+        'benchmark': 0.9,
+        'higher_is_better': True,
+        'category': 'liquidity',
+        'description': '(Cash + Receivables) / Current Liabilities',
+    },
+    'cash_ratio': {
+        'benchmark': 0.2,
+        'higher_is_better': True,
+        'years': [2021, 2022, 2023],  # Exclude 2020 outlier
+        'category': 'liquidity',
+        'description': 'Cash / Current Liabilities',
+    },
+    'cash_conversion_cycle': {
+        'benchmark': 75,
+        'higher_is_better': False,
+        'category': 'liquidity',
+        'description': 'DIO + DRO - DPO (days)',
+    },
+
+    # -------------------------------------------------------------------------
+    # WORKING CAPITAL
+    # -------------------------------------------------------------------------
+    'inventory_turnover': {
+        'benchmark': 6,
+        'higher_is_better': True,
+        'category': 'working_capital',
+        'description': 'COGS / Average Inventory',
+    },
+    'days_inventory_outstanding': {
+        'benchmark': 60,
+        'higher_is_better': False,
+        'category': 'working_capital',
+        'description': '365 / Inventory Turnover',
+    },
+    'receivables_turnover': {
+        'benchmark': 6,
+        'higher_is_better': True,
+        'category': 'working_capital',
+        'description': 'Revenue / Average Receivables',
+    },
+    'days_receivables_outstanding': {
+        'benchmark': 60,
+        'higher_is_better': False,
+        'category': 'working_capital',
+        'description': '365 / Receivables Turnover',
+    },
+    'payables_turnover': {
+        'benchmark': 8,
+        'higher_is_better': True,
+        'category': 'working_capital',
+        'description': 'COGS / Average Payables',
+    },
+    'days_payables_outstanding': {
+        'benchmark': 45,
+        'higher_is_better': False,
+        'category': 'working_capital',
+        'description': '365 / Payables Turnover',
+    },
+
+    # -------------------------------------------------------------------------
+    # ACTIVITY
+    # -------------------------------------------------------------------------
+    'working_capital_turnover': {
+        'benchmark': 5,
+        'higher_is_better': True,
+        'category': 'activity',
+        'description': 'Revenue / Average Working Capital',
+    },
+    'total_assets_turnover': {
+        'benchmark': 3,
+        'higher_is_better': True,
+        'category': 'activity',
+        'description': 'Revenue / Average Total Assets',
+    },
+
+    # -------------------------------------------------------------------------
+    # SOLVENCY
+    # -------------------------------------------------------------------------
+    'debt_to_total_assets': {
+        'benchmark': 0.25,
+        'higher_is_better': False,
+        'category': 'solvency',
+        'description': 'Total Debt / Total Assets',
+    },
+    'debt_to_capital': {
+        'benchmark': 0.30,
+        'higher_is_better': False,
+        'category': 'solvency',
+        'description': 'Total Debt / (Debt + Equity)',
+    },
+    'debt_to_equity': {
+        'benchmark': 0.50,
+        'higher_is_better': False,
+        'category': 'solvency',
+        'description': 'Total Debt / Equity',
+    },
+    'equity_to_assets': {
+        'benchmark': 0.30,
+        'higher_is_better': True,
+        'category': 'solvency',
+        'description': 'Equity / Total Assets',
+    },
+    'debt_to_ebitda': {
+        'benchmark': 5,
+        'higher_is_better': False,
+        'category': 'solvency',
+        'description': 'Total Debt / EBITDA',
+    },
+    'interest_coverage': {
+        'benchmark': 2.5,
+        'higher_is_better': True,
+        'category': 'solvency',
+        'description': 'EBITDA / Interest Expense',
+    },
+    # Example: Add DSCR when debt service data is available
+    # 'dscr': {
+    #     'benchmark': 1.25,
+    #     'higher_is_better': True,
+    #     'category': 'solvency',
+    #     'description': 'Debt Service Coverage Ratio',
+    # },
+
+    # -------------------------------------------------------------------------
+    # RELATED PARTY & OTHER
+    # -------------------------------------------------------------------------
+    'related_parties_receivable_ratio': {
+        'benchmark': 0.15,
+        'higher_is_better': False,
+        'category': 'related_party',
+        'description': 'Due from Related / Current Assets',
+    },
+    'related_parties_payable_ratio': {
+        'benchmark': 0.15,
+        'higher_is_better': False,
+        'category': 'related_party',
+        'description': 'Due to Related / Current Liabilities',
+    },
+    'dividend_payout_ratio': {
+        'benchmark': 0.20,
+        'higher_is_better': False,
+        'category': 'other',
+        'description': 'Dividends / Net Profit',
+    },
+    'shareholder_account_cashflow': {
+        'benchmark': 0,
+        'higher_is_better': False,
+        'category': 'related_party',
+        'description': 'Change in Shareholder Current Account',
+    },
+    'shareholder_account_to_equity': {
+        'benchmark': 0.30,
+        'higher_is_better': False,
+        'category': 'related_party',
+        'description': 'Shareholder Current Account / Equity',
+    },
+
+    # -------------------------------------------------------------------------
+    # FACILITY LIMITS
+    # -------------------------------------------------------------------------
+    'facility_to_equity': {
+        'benchmark': 0.10,
+        'higher_is_better': False,
+        'use_latest': True,
+        'category': 'facility',
+        'description': 'Facility Limit / Equity',
+    },
+    'facility_to_working_capital': {
+        'benchmark': 0.50,
+        'higher_is_better': False,
+        'use_latest': True,
+        'category': 'facility',
+        'description': 'Facility Limit / Working Capital',
+    },
+
+    # -------------------------------------------------------------------------
+    # RISK SCORES
+    # -------------------------------------------------------------------------
+    'altman_z_score': {
+        'benchmark': 2.6,
+        'higher_is_better': True,
+        'use_latest': True,
+        'category': 'risk_score',
+        'description': "Altman Z''-Score (Emerging Markets)",
+    },
+}
+
+# Qualitative scoring lookups
+QUALITATIVE_CONFIG = {
+    'year_established': {
+        'max_score': 2,
+        'description': 'Years in operation',
+        'scoring': 'custom',  # Uses custom function
+    },
+    'size': {
+        'max_score': 2,
+        'description': 'Business size based on revenue',
+        'values': {'Small': 0, 'Medium': 1, 'Large': 2},
+    },
+    'jurisdiction_risk': {
+        'max_score': 2,
+        'description': 'Country/jurisdiction risk level',
+        'values': {'Low': 1, 'Medium': 0.5, 'High': 0},
+    },
+    'industry_risk': {
+        'max_score': 1,
+        'description': 'Industry risk level',
+        'values': {'Low': 1, 'Medium': 0.5, 'High': 0},
+    },
+    'auditor_quality': {
+        'max_score': 1.5,
+        'description': 'Quality of auditing firm',
+        'values': {'Big 4': 1.5, 'Mid-tier firm': 1, 'Regional firm': 0.5, 'Small practice': 0},
+    },
+    'years_partnership': {
+        'max_score': 2,
+        'description': 'Years in partnership with lender',
+        'values': {'Less than 1 year': 0, 'Between 1 and 5 years': 1,
+                   'More than 5 years': 2, 'Not available': 0},
+    },
+    'payment_performance': {
+        'max_score': 2,
+        'description': 'Historical payment performance',
+        'values': {'Excellent': 2, 'Decent': 0.5, 'Poor': -5, 'Not available': 0},
+    },
+    'dnb_report': {
+        'max_score': 0.5,
+        'description': 'D&B report available',
+        'values': {'Yes': 0.5, 'No': 0},
+    },
+    'kyc_cleared': {
+        'max_score': 0.5,
+        'description': 'KYC checks cleared',
+        'values': {'Yes': 0.5, 'No': -20},
+    },
+}
+
+
+# =============================================================================
+# 2. FINANCIAL DATA CLASSES
+# =============================================================================
+
+@dataclass
+class IncomeStatement:
+    """Income statement data for a single year."""
+    year: int
+    revenue: float
+    cost_of_sales: float
+    sga: float
+    da: float
+    finance_cost: float
+    other_non_operating: float = 0
+    # Add fields as needed for new ratios
+    debt_service: float = 0  # For DSCR calculation
+
+    @property
+    def gross_profit(self) -> float:
+        return self.revenue - self.cost_of_sales
+
+    @property
+    def operating_profit(self) -> float:
+        return self.gross_profit - self.sga - self.da
+
+    @property
+    def ebitda(self) -> float:
+        return self.operating_profit + self.da
+
+    @property
+    def net_profit(self) -> float:
+        return self.operating_profit - self.finance_cost + self.other_non_operating
+
+
+@dataclass
+class BalanceSheet:
+    """Balance sheet data for a single year."""
+    year: int
+    ppe: float
+    cash: float
+    trade_receivables: float
+    inventory: float
+    due_from_related_parties: float = 0
+    other_current_assets: float = 0
+    share_capital: float = 0
+    retained_earnings: float = 0
+    shareholder_current_account: float = 0
+    other_equity: float = 0
+    other_non_current_liabilities: float = 0
+    long_term_debt: float = 0
+    trade_payables: float = 0
+    other_current_liabilities: float = 0
+    due_to_related_parties: float = 0
+    # Add fields for new ratios
+    short_term_debt: float = 0
+
+    @property
+    def current_assets(self) -> float:
+        return (self.cash + self.trade_receivables + self.inventory +
+                self.due_from_related_parties + self.other_current_assets)
+
+    @property
+    def total_assets(self) -> float:
+        return self.ppe + self.current_assets
+
+    @property
+    def equity(self) -> float:
+        return (self.share_capital + self.retained_earnings +
+                self.shareholder_current_account + self.other_equity)
+
+    @property
+    def non_current_liabilities(self) -> float:
+        return self.other_non_current_liabilities + self.long_term_debt
+
+    @property
+    def current_liabilities(self) -> float:
+        return (self.trade_payables + self.other_current_liabilities +
+                self.due_to_related_parties + self.short_term_debt)
+
+    @property
+    def total_liabilities(self) -> float:
+        return self.non_current_liabilities + self.current_liabilities
+
+    @property
+    def total_debt(self) -> float:
+        return self.long_term_debt + self.short_term_debt
+
+    @property
+    def working_capital(self) -> float:
+        return self.trade_receivables + self.inventory - self.trade_payables
+
+
+@dataclass
+class CashFlowStatement:
+    """Cash flow statement data for a single year."""
+    year: int
+    profit_before_tax: float
+    non_cash_items: float = 0
+    working_capital_changes: float = 0
+    capex: float = 0
+    shareholder_account_changes: float = 0
+    dividends_paid: float = 0
+
+    @property
+    def cash_from_operations(self) -> float:
+        return self.profit_before_tax + self.non_cash_items + self.working_capital_changes
+
+
+@dataclass
+class FinancialYear:
+    """Container for all financial statements for a single year."""
+    income_statement: IncomeStatement
+    balance_sheet: BalanceSheet
+    cash_flow: CashFlowStatement
+
+    @property
+    def year(self) -> int:
+        return self.income_statement.year
+
+
+# =============================================================================
+# 3. RATIO CALCULATOR
+# =============================================================================
+
+class RatioCalculator:
+    """
+    Calculate financial ratios from multi-year data.
+
+    To add a new ratio:
+    1. Add a method here with signature: def ratio_name(self, year: int) -> Optional[float]
+    2. Add the config entry in METRIC_CONFIG above
+    """
+
+    def __init__(self, years_data: List[FinancialYear]):
+        self.years = sorted(years_data, key=lambda x: x.year)
+        self.years_map = {y.year: y for y in self.years}
+        self.all_years = [y.year for y in self.years]
+        self.latest_year = max(self.all_years)
+
+    def _safe_divide(self, num: float, denom: float) -> Optional[float]:
+        if denom == 0 or denom is None:
+            return None
+        return num / denom
+
+    # -------------------------------------------------------------------------
+    # PROFITABILITY
+    # -------------------------------------------------------------------------
+
+    def revenue_cagr(self) -> Optional[float]:
+        """Compound annual growth rate of revenue."""
+        if len(self.years) < 2:
+            return None
+        first = self.years[0].income_statement.revenue
+        last = self.years[-1].income_statement.revenue
+        if first <= 0:
+            return None
+        n_periods = len(self.years)
+        return (last / first) ** (1 / n_periods) - 1
+
+    def gross_profit_margin(self, year: int) -> Optional[float]:
+        fy = self.years_map[year]
+        return self._safe_divide(fy.income_statement.gross_profit,
+                                  fy.income_statement.revenue)
+
+    def operating_profit_margin(self, year: int) -> Optional[float]:
+        fy = self.years_map[year]
+        return self._safe_divide(fy.income_statement.operating_profit,
+                                  fy.income_statement.revenue)
+
+    def net_profit_margin(self, year: int) -> Optional[float]:
+        fy = self.years_map[year]
+        return self._safe_divide(fy.income_statement.net_profit,
+                                  fy.income_statement.revenue)
+
+    def return_on_assets(self, year: int) -> Optional[float]:
+        fy = self.years_map[year]
+        return self._safe_divide(fy.income_statement.net_profit,
+                                  fy.balance_sheet.total_assets)
+
+    def return_on_equity(self, year: int) -> Optional[float]:
+        fy = self.years_map[year]
+        return self._safe_divide(fy.income_statement.net_profit,
+                                  fy.balance_sheet.equity)
+
+    # -------------------------------------------------------------------------
+    # LIQUIDITY
+    # -------------------------------------------------------------------------
+
+    def current_ratio(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.current_assets, bs.current_liabilities)
+
+    def quick_ratio(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.cash + bs.trade_receivables,
+                                  bs.current_liabilities)
+
+    def cash_ratio(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.cash, bs.current_liabilities)
+
+    def cash_conversion_cycle(self, year: int) -> Optional[float]:
+        dio = self.days_inventory_outstanding(year)
+        dro = self.days_receivables_outstanding(year)
+        dpo = self.days_payables_outstanding(year)
+        if any(v is None for v in [dio, dro, dpo]):
+            return None
+        return dio + dro - dpo
+
+    # -------------------------------------------------------------------------
+    # WORKING CAPITAL
+    # -------------------------------------------------------------------------
+
+    def inventory_turnover(self, year: int) -> Optional[float]:
+        if year - 1 not in self.years_map:
+            return None
+        curr = self.years_map[year]
+        prev = self.years_map[year - 1]
+        avg_inv = (curr.balance_sheet.inventory + prev.balance_sheet.inventory) / 2
+        return self._safe_divide(curr.income_statement.cost_of_sales, avg_inv)
+
+    def days_inventory_outstanding(self, year: int) -> Optional[float]:
+        turnover = self.inventory_turnover(year)
+        return self._safe_divide(365, turnover) if turnover else None
+
+    def receivables_turnover(self, year: int) -> Optional[float]:
+        if year - 1 not in self.years_map:
+            return None
+        curr = self.years_map[year]
+        prev = self.years_map[year - 1]
+        avg_rec = (curr.balance_sheet.trade_receivables +
+                   prev.balance_sheet.trade_receivables) / 2
+        return self._safe_divide(curr.income_statement.revenue, avg_rec)
+
+    def days_receivables_outstanding(self, year: int) -> Optional[float]:
+        turnover = self.receivables_turnover(year)
+        return self._safe_divide(365, turnover) if turnover else None
+
+    def payables_turnover(self, year: int) -> Optional[float]:
+        if year - 1 not in self.years_map:
+            return None
+        curr = self.years_map[year]
+        prev = self.years_map[year - 1]
+        avg_pay = (curr.balance_sheet.trade_payables +
+                   prev.balance_sheet.trade_payables) / 2
+        return self._safe_divide(curr.income_statement.cost_of_sales, avg_pay)
+
+    def days_payables_outstanding(self, year: int) -> Optional[float]:
+        turnover = self.payables_turnover(year)
+        return self._safe_divide(365, turnover) if turnover else None
+
+    # -------------------------------------------------------------------------
+    # ACTIVITY
+    # -------------------------------------------------------------------------
+
+    def working_capital_turnover(self, year: int) -> Optional[float]:
+        if year - 1 not in self.years_map:
+            return None
+        curr = self.years_map[year]
+        prev = self.years_map[year - 1]
+        avg_wc = (curr.balance_sheet.working_capital +
+                  prev.balance_sheet.working_capital) / 2
+        return self._safe_divide(curr.income_statement.revenue, avg_wc)
+
+    def total_assets_turnover(self, year: int) -> Optional[float]:
+        if year - 1 not in self.years_map:
+            return None
+        curr = self.years_map[year]
+        prev = self.years_map[year - 1]
+        avg_ta = (curr.balance_sheet.total_assets +
+                  prev.balance_sheet.total_assets) / 2
+        return self._safe_divide(curr.income_statement.revenue, avg_ta)
+
+    # -------------------------------------------------------------------------
+    # SOLVENCY
+    # -------------------------------------------------------------------------
+
+    def debt_to_total_assets(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.total_debt, bs.total_assets)
+
+    def debt_to_capital(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.total_debt, bs.total_debt + bs.equity)
+
+    def debt_to_equity(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.total_debt, bs.equity)
+
+    def equity_to_assets(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.equity, bs.total_assets)
+
+    def debt_to_ebitda(self, year: int) -> Optional[float]:
+        fy = self.years_map[year]
+        return self._safe_divide(fy.balance_sheet.total_debt,
+                                  fy.income_statement.ebitda)
+
+    def interest_coverage(self, year: int) -> Optional[float]:
+        inc = self.years_map[year].income_statement
+        return self._safe_divide(inc.ebitda, inc.finance_cost)
+
+    def dscr(self, year: int) -> Optional[float]:
+        """Debt Service Coverage Ratio = EBITDA / Debt Service."""
+        fy = self.years_map[year]
+        debt_service = fy.income_statement.debt_service
+        if debt_service == 0:
+            return None  # No debt service data
+        return self._safe_divide(fy.income_statement.ebitda, debt_service)
+
+    # -------------------------------------------------------------------------
+    # RELATED PARTY & OTHER
+    # -------------------------------------------------------------------------
+
+    def related_parties_receivable_ratio(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.due_from_related_parties, bs.current_assets)
+
+    def related_parties_payable_ratio(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.due_to_related_parties, bs.current_liabilities)
+
+    def dividend_payout_ratio(self, year: int) -> Optional[float]:
+        fy = self.years_map[year]
+        return self._safe_divide(abs(fy.cash_flow.dividends_paid),
+                                  fy.income_statement.net_profit)
+
+    def shareholder_account_to_equity(self, year: int) -> Optional[float]:
+        bs = self.years_map[year].balance_sheet
+        return self._safe_divide(bs.shareholder_current_account, bs.equity)
+
+    def shareholder_account_cashflow(self, year: int) -> Optional[float]:
+        if year - 1 not in self.years_map:
+            return None
+        curr = self.years_map[year].balance_sheet.shareholder_current_account
+        prev = self.years_map[year - 1].balance_sheet.shareholder_current_account
+        return curr - prev
+
+
+# =============================================================================
+# 4. ALTMAN Z-SCORE
+# =============================================================================
+
+class AltmanZScore:
+    """Altman Z''-Score for Emerging Markets."""
+
+    WEIGHTS = {'A': 6.72, 'C': 1.05, 'D': 6.50, 'E': 3.26}
+    CONSTANT = 3.25
+    SAFE_THRESHOLD = 2.6
+    DISTRESS_THRESHOLD = 1.1
+
+    def __init__(self, years_data: List[FinancialYear]):
+        self.years = sorted(years_data, key=lambda x: x.year)
+
+    def calculate(self, year: int) -> Optional[Dict]:
+        fy = next((y for y in self.years if y.year == year), None)
+        if not fy:
+            return None
+
+        bs = fy.balance_sheet
+        inc = fy.income_statement
+
+        A = inc.operating_profit / bs.total_assets if bs.total_assets else 0
+        C = bs.equity / bs.total_liabilities if bs.total_liabilities else 0
+        D = bs.working_capital / bs.total_assets if bs.total_assets else 0
+        E = bs.retained_earnings / bs.total_assets if bs.total_assets else 0
+
+        z_score = (self.CONSTANT +
+                   self.WEIGHTS['A'] * A +
+                   self.WEIGHTS['C'] * C +
+                   self.WEIGHTS['D'] * D +
+                   self.WEIGHTS['E'] * E)
+
+        if z_score > self.SAFE_THRESHOLD:
+            interpretation = "Safe"
+        elif z_score > self.DISTRESS_THRESHOLD:
+            interpretation = "Grey Area"
+        else:
+            interpretation = "Distress"
+
+        return {'year': year, 'z_score': z_score, 'interpretation': interpretation}
+
+
+# =============================================================================
+# 5. BENEISH M-SCORE
+# =============================================================================
+
+class BeneishMScore:
+    """Beneish M-Score for detecting earnings manipulation."""
+
+    WEIGHTS = {
+        'DSRI': 0.92, 'GMI': 0.528, 'SGI': 0.892, 'DEPI': 0.115,
+        'SGAI': 0.172, 'TATA': 4.679, 'LVGI': 0.327
+    }
+    CONSTANT = -4.84
+
+    def __init__(self, years_data: List[FinancialYear]):
+        self.years = sorted(years_data, key=lambda x: x.year)
+        self.years_map = {y.year: y for y in self.years}
+
+    def _safe_divide(self, num, denom):
+        return num / denom if denom and denom != 0 else None
+
+    def calculate(self, year: int) -> Optional[Dict]:
+        if year - 1 not in self.years_map:
+            return None
+
+        curr = self.years_map[year]
+        prev = self.years_map[year - 1]
+        curr_bs, curr_inc, curr_cf = curr.balance_sheet, curr.income_statement, curr.cash_flow
+        prev_bs, prev_inc = prev.balance_sheet, prev.income_statement
+
+        # Calculate indices
+        curr_dsr = self._safe_divide(curr_bs.trade_receivables, curr_inc.revenue)
+        prev_dsr = self._safe_divide(prev_bs.trade_receivables, prev_inc.revenue)
+        dsri = self._safe_divide(curr_dsr, prev_dsr) if curr_dsr and prev_dsr else 1
+
+        curr_gpm = self._safe_divide(curr_inc.gross_profit, curr_inc.revenue)
+        prev_gpm = self._safe_divide(prev_inc.gross_profit, prev_inc.revenue)
+        gmi = self._safe_divide(prev_gpm, curr_gpm) if curr_gpm and prev_gpm else 1
+
+        sgi = self._safe_divide(curr_inc.revenue, prev_inc.revenue) or 1
+
+        curr_dep = self._safe_divide(curr_inc.da, curr_bs.ppe + curr_inc.da)
+        prev_dep = self._safe_divide(prev_inc.da, prev_bs.ppe + prev_inc.da)
+        depi = self._safe_divide(prev_dep, curr_dep) if curr_dep and prev_dep else 1
+
+        curr_sga = self._safe_divide(curr_inc.sga, curr_inc.revenue)
+        prev_sga = self._safe_divide(prev_inc.sga, prev_inc.revenue)
+        sgai = self._safe_divide(curr_sga, prev_sga) if curr_sga and prev_sga else 1
+
+        curr_lev = self._safe_divide(curr_bs.current_liabilities + curr_bs.long_term_debt,
+                                      curr_bs.total_assets)
+        prev_lev = self._safe_divide(prev_bs.current_liabilities + prev_bs.long_term_debt,
+                                      prev_bs.total_assets)
+        lvgi = self._safe_divide(curr_lev, prev_lev) if curr_lev and prev_lev else 1
+
+        tata = self._safe_divide(curr_inc.net_profit - curr_cf.cash_from_operations,
+                                  curr_bs.total_assets) or 0
+
+        m_score = (self.CONSTANT +
+                   self.WEIGHTS['DSRI'] * dsri +
+                   self.WEIGHTS['GMI'] * gmi +
+                   self.WEIGHTS['SGI'] * sgi +
+                   self.WEIGHTS['DEPI'] * depi -
+                   self.WEIGHTS['SGAI'] * sgai +
+                   self.WEIGHTS['TATA'] * tata -
+                   self.WEIGHTS['LVGI'] * lvgi)
+
+        if m_score < -2.22:
+            interpretation = "Unlikely manipulation"
+        elif m_score <= -1.78:
+            interpretation = "Possible manipulation"
+        else:
+            interpretation = "Likely manipulation"
+
+        return {'year': year, 'm_score': m_score, 'interpretation': interpretation}
+
+
+# =============================================================================
+# 6. SCORING ENGINE (Config-Driven)
+# =============================================================================
+
+@dataclass
+class ScoringResult:
+    """Result of scoring a single metric."""
+    name: str
+    value: Optional[float]
+    benchmark: float
+    score: int
+    passed: bool
+    category: str
+    description: str
+
+
+class ScoringEngine:
+    """
+    Config-driven scoring engine.
+
+    Automatically scores any metric that:
+    1. Has an entry in METRIC_CONFIG
+    2. Has a corresponding method in RatioCalculator (or special handling)
+    """
+
+    def __init__(self, calc: RatioCalculator, altman: AltmanZScore,
+                 facility_limit: float = 0, config: Dict = None):
+        self.calc = calc
+        self.altman = altman
+        self.facility_limit = facility_limit
+        self.config = config or METRIC_CONFIG
+        self.years = calc.all_years
+        self.latest = calc.latest_year
+
+    def _get_values(self, metric_name: str, years: List[int] = None) -> List[Optional[float]]:
+        """Get ratio values for specified years."""
+        target_years = years if years else self.years
+
+        # Special cases
+        if metric_name == 'revenue_cagr':
+            return [self.calc.revenue_cagr()]
+        elif metric_name == 'altman_z_score':
+            result = self.altman.calculate(self.latest)
+            return [result['z_score']] if result else []
+        elif metric_name == 'facility_to_equity':
+            bs = self.calc.years_map[self.latest].balance_sheet
+            return [self.calc._safe_divide(self.facility_limit, bs.equity)]
+        elif metric_name == 'facility_to_working_capital':
+            bs = self.calc.years_map[self.latest].balance_sheet
+            return [self.calc._safe_divide(self.facility_limit, bs.working_capital)]
+
+        # Standard case: call method on calculator
+        method = getattr(self.calc, metric_name, None)
+        if not method:
+            return []
+        return [method(y) for y in target_years if y in self.calc.years_map]
+
+    def _score_metric(self, name: str, config: Dict) -> Optional[ScoringResult]:
+        """Score a single metric based on its config."""
+        # Get values for appropriate years
+        years = config.get('years', None)
+        values = self._get_values(name, years)
+
+        valid = [v for v in values if v is not None]
+        if not valid:
+            return None
+
+        # Determine value to compare
+        if config.get('use_latest'):
+            value = valid[-1]
+        else:
+            value = np.mean(valid)
+
+        benchmark = config['benchmark']
+        higher_better = config['higher_is_better']
+        passed = value >= benchmark if higher_better else value <= benchmark
+
+        return ScoringResult(
+            name=name,
+            value=value,
+            benchmark=benchmark,
+            score=1 if passed else 0,
+            passed=passed,
+            category=config.get('category', 'other'),
+            description=config.get('description', ''),
+        )
+
+    def score_all(self) -> Dict[str, ScoringResult]:
+        """Score all configured metrics."""
+        results = {}
+        for name, config in self.config.items():
+            result = self._score_metric(name, config)
+            if result is not None:
+                results[name] = result
+        return results
+
+
+# =============================================================================
+# 7. QUALITATIVE SCORING
+# =============================================================================
+
+@dataclass
+class QualitativeInputs:
+    """Qualitative assessment inputs."""
+    year_established: int
+    size: str
+    jurisdiction_risk: str
+    industry_risk: str
+    auditor_quality: str
+    years_partnership: str
+    payment_performance: str
+    dnb_report_available: str
+    kyc_cleared: str
+    facility_limit: float = 0
+
+
+class QualitativeScorer:
+    """Config-driven qualitative scorer."""
+
+    def __init__(self, config: Dict = None):
+        self.config = config or QUALITATIVE_CONFIG
+
+    def _score_year_established(self, year: int, current_year: int = 2025) -> float:
+        age = current_year - year
+        if age < 5:
+            return -2
+        elif age <= 15:
+            return 1
+        return 2
+
+    def score(self, inputs: QualitativeInputs) -> Dict[str, Tuple[float, float]]:
+        """Return {category: (score, max_score)}."""
+        results = {}
+
+        for key, config in self.config.items():
+            max_score = config['max_score']
+
+            if key == 'year_established':
+                score = self._score_year_established(inputs.year_established)
+            elif key == 'dnb_report':
+                score = config['values'].get(inputs.dnb_report_available, 0)
+            elif key == 'kyc_cleared':
+                score = config['values'].get(inputs.kyc_cleared, 0)
+            else:
+                value = getattr(inputs, key, None)
+                score = config['values'].get(value, 0) if value else 0
+
+            results[key] = (score, max_score)
+
+        return results
+
+
+# =============================================================================
+# 8. CREDIT SCORING PIPELINE
+# =============================================================================
+
+@dataclass
+class CreditScoreOutput:
+    """Final credit scoring output."""
+    total_score: float
+    max_score: float
+    score_percentage: float
+    tier: int
+    quantitative_results: Dict[str, ScoringResult]
+    qualitative_results: Dict[str, Tuple[float, float]]
+    altman_z_score: Dict
+    beneish_m_score: Optional[Dict]
+
+
+class CreditScoringPipeline:
+    """Main pipeline orchestrating the full credit scoring process."""
+
+    TIER_THRESHOLDS = [(0.75, 1), (0.50, 2), (0.30, 3), (0.00, 4)]
+
+    def __init__(self, years_data: List[FinancialYear], qualitative: QualitativeInputs,
+                 metric_config: Dict = None, qualitative_config: Dict = None):
+        self.years_data = years_data
+        self.qualitative = qualitative
+        self.metric_config = metric_config or METRIC_CONFIG
+        self.qualitative_config = qualitative_config or QUALITATIVE_CONFIG
+        self.latest_year = max(y.year for y in years_data)
+
+        # Initialize components
+        self.ratio_calc = RatioCalculator(years_data)
+        self.altman = AltmanZScore(years_data)
+        self.beneish = BeneishMScore(years_data)
+        self.qual_scorer = QualitativeScorer(self.qualitative_config)
+
+    def _determine_tier(self, pct: float) -> int:
+        for threshold, tier in self.TIER_THRESHOLDS:
+            if pct >= threshold:
+                return tier
+        return 4
+
+    def run(self) -> CreditScoreOutput:
+        """Execute the full credit scoring pipeline."""
+        scoring_engine = ScoringEngine(
+            self.ratio_calc, self.altman, self.qualitative.facility_limit,
+            self.metric_config
+        )
+        quant_results = scoring_engine.score_all()
+        altman_result = self.altman.calculate(self.latest_year)
+        beneish_result = self.beneish.calculate(self.latest_year)
+        qual_results = self.qual_scorer.score(self.qualitative)
+
+        quant_score = sum(r.score for r in quant_results.values())
+        quant_max = len(quant_results)
+        qual_score = sum(s for s, _ in qual_results.values())
+        qual_max = sum(m for _, m in qual_results.values())
+
+        total = quant_score + qual_score
+        max_total = quant_max + qual_max
+        pct = total / max_total if max_total else 0
+
+        return CreditScoreOutput(
+            total_score=total,
+            max_score=max_total,
+            score_percentage=pct,
+            tier=self._determine_tier(pct),
+            quantitative_results=quant_results,
+            qualitative_results=qual_results,
+            altman_z_score=altman_result,
+            beneish_m_score=beneish_result
+        )
+
+    def generate_report(self) -> str:
+        """Generate a text report grouped by category."""
+        result = self.run()
+
+        lines = [
+            "=" * 60,
+            "CREDIT SCORING REPORT",
+            "=" * 60,
+            f"\nFINAL SCORE: {result.total_score:.1f} / {result.max_score:.1f}",
+            f"PERCENTAGE: {result.score_percentage:.1%}",
+            f"CREDIT TIER: {result.tier}",
+        ]
+
+        # Group quantitative by category
+        categories = {}
+        for name, r in result.quantitative_results.items():
+            cat = r.category
+            if cat not in categories:
+                categories[cat] = []
+            categories[cat].append((name, r))
+
+        lines.append("\n" + "-" * 40)
+        lines.append("QUANTITATIVE METRICS BY CATEGORY:")
+        for cat in sorted(categories.keys()):
+            lines.append(f"\n  [{cat.upper()}]")
+            for name, r in sorted(categories[cat]):
+                status = "+" if r.passed else "-"
+                val = f"{r.value:.4f}" if r.value is not None else "N/A"
+                lines.append(f"    {status} {name}: {val} (benchmark: {r.benchmark})")
+
+        lines.append("\n" + "-" * 40)
+        lines.append("QUALITATIVE METRICS:")
+        for name, (score, max_s) in sorted(result.qualitative_results.items()):
+            lines.append(f"  {name}: {score} / {max_s}")
+
+        lines.append("\n" + "-" * 40)
+        lines.append("RISK SCORES:")
+        z = result.altman_z_score
+        lines.append(f"  Altman Z'': {z['z_score']:.2f} - {z['interpretation']}")
+        if result.beneish_m_score:
+            m = result.beneish_m_score
+            lines.append(f"  Beneish M: {m['m_score']:.2f} - {m['interpretation']}")
+
+        lines.append("\n" + "=" * 60)
+        return "\n".join(lines)
+
+
+# =============================================================================
+# 9. TEST DATA & VALIDATION
+# =============================================================================
+
+def create_test_data() -> Tuple[List[FinancialYear], QualitativeInputs]:
+    """Create test data matching the Excel workbook."""
+    years_data = [
+        FinancialYear(
+            IncomeStatement(2020, 424940890, 404676036, 5220334, 14640, 41816, 23425),
+            BalanceSheet(2020, 37419, 5599501, 24564704, 50286283, 535928, 783984,
+                        300000, 34456557, 38854677, 150000, 266115, 0, 7687963, 92507, 0),
+            CashFlowStatement(2020, 15011489, 64805, -20934909, -16796, 9491050, 0)
+        ),
+        FinancialYear(
+            IncomeStatement(2021, 454349724, 429066388, 5690820, 20396, 80286, 0),
+            BalanceSheet(2021, 42935, 3361003, 42065112, 81865995, 769153, 1170637,
+                        300000, 45842790, 58135783, 150000, 317404, 0, 22445666, 2083192, 0),
+            CashFlowStatement(2021, 19491834, 71685, -32951610, -25912, 11175506, 0)
+        ),
+        FinancialYear(
+            IncomeStatement(2022, 498772338, 476742326, 7645430, 59325, 67273, 173444),
+            BalanceSheet(2022, 262609, 3561291, 49094866, 113001404, 421654, 1205312,
+                        300000, 55158922, 52584175, 150000, 642403, 0, 57708027, 1003609, 0),
+            CashFlowStatement(2022, 14431428, 384324, -3669561, -278999, -10666904, 0)
+        ),
+        FinancialYear(
+            IncomeStatement(2023, 596163040, 573043229, 9653846, 85242, 58289, 50132),
+            BalanceSheet(2023, 202673, 3949339, 70234333, 101217024, 640131, 1427344,
+                        300000, 68531488, 42860507, 150000, 874103, 0, 62481645, 2473101, 0),
+            CashFlowStatement(2023, 13372566, 316942, -3525486, -25306, -9723668, 0)
+        ),
+    ]
+
+    qualitative = QualitativeInputs(
+        year_established=2004,
+        size='Large',
+        jurisdiction_risk='Medium',
+        industry_risk='Medium',
+        auditor_quality='Small practice',
+        years_partnership='More than 5 years',
+        payment_performance='Excellent',
+        dnb_report_available='Yes',
+        kyc_cleared='Yes',
+        facility_limit=0
+    )
+
+    return years_data, qualitative
+
+
+def run_validation():
+    """Run validation tests."""
+    print("=" * 60)
+    print("CREDIT SCORING MODEL - VALIDATION")
+    print("=" * 60)
+
+    years_data, qualitative = create_test_data()
+    pipeline = CreditScoringPipeline(years_data, qualitative)
+    result = pipeline.run()
+
+    print(f"\n  Total Score: {result.total_score:.1f} / {result.max_score:.1f}")
+    print(f"  Percentage:  {result.score_percentage:.1%}")
+    print(f"  Tier:        {result.tier}")
+    print(f"\n  Expected:    36 / 45.5 = 79.1%, Tier 1")
+
+    match = abs(result.score_percentage - 0.791) < 0.01 and result.tier == 1
+    print(f"\n  Result:      {'PASS' if match else 'FAIL'}")
+    print("=" * 60)
+
+    return match
+
+
+if __name__ == "__main__":
+    run_validation()
+    print("\n" + "=" * 60)
+    print("HOW TO ADD A NEW RATIO (e.g., DSCR)")
+    print("=" * 60)
+    print("""
+1. Add field to data class (if needed):
+   IncomeStatement.debt_service: float = 0
+
+2. Add method to RatioCalculator:
+   def dscr(self, year: int) -> Optional[float]:
+       fy = self.years_map[year]
+       return self._safe_divide(fy.income_statement.ebitda,
+                                fy.income_statement.debt_service)
+
+3. Add config entry in METRIC_CONFIG:
+   'dscr': {
+       'benchmark': 1.25,
+       'higher_is_better': True,
+       'category': 'solvency',
+       'description': 'EBITDA / Debt Service',
+   },
+
+That's it! The scoring engine will automatically pick it up.
+""")
+`;
+
+const creditScoringRunCode = `
+"""Minimal Credit Scoring Model - 79.1% = 36/45.5, Tier 1"""
+from dataclasses import dataclass
+from typing import Dict, List
+import numpy as np
+
+@dataclass
+class FY:
+    year: int; rev: float; cogs: float; sga: float; da: float; fin_cost: float; other: float
+    ppe: float; cash: float; recv: float; inv: float; rel_recv: float; other_ca: float
+    share_cap: float; ret_earn: float; sh_acct: float; other_eq: float
+    ncl: float; ltd: float; payables: float; other_cl: float; rel_pay: float
+    pbt: float; non_cash: float; wc_chg: float
+    gp = property(lambda s: s.rev - s.cogs)
+    op = property(lambda s: s.gp - s.sga - s.da)
+    np_ = property(lambda s: s.op - s.fin_cost + s.other)
+    ebitda = property(lambda s: s.op + s.da)
+    ca = property(lambda s: s.cash + s.recv + s.inv + s.rel_recv + s.other_ca)
+    ta = property(lambda s: s.ppe + s.ca)
+    eq = property(lambda s: s.share_cap + s.ret_earn + s.sh_acct + s.other_eq)
+    cl = property(lambda s: s.payables + s.other_cl + s.rel_pay)
+    tl = property(lambda s: s.ncl + s.ltd + s.cl)
+    wc = property(lambda s: s.recv + s.inv - s.payables)
+    cfo = property(lambda s: s.pbt + s.non_cash + s.wc_chg)
+
+def d(a, b): return a / b if b else None
+
+def score(data: List[FY], q: Dict, fac: float = 0) -> tuple:
+    m = {y.year: y for y in data}; yrs = sorted(m.keys()); L = m[max(yrs)]
+    def av(fn, yr=yrs): v = [fn(m[y]) for y in yr if y in m and fn(m[y]) is not None]; return np.mean(v) if v else None
+    def av2(fn, yr=yrs): v = [fn(m[y],m[y-1]) for y in yr if y in m and y-1 in m]; return np.mean([x for x in v if x]) if v else None
+
+    # Helper for days ratios: compute days per year, then average
+    dio = av2(lambda c,p: d(365, d(c.cogs,(c.inv+p.inv)/2)))
+    dro = av2(lambda c,p: d(365, d(c.rev,(c.recv+p.recv)/2)))
+    dpo = av2(lambda c,p: d(365, d(c.cogs,(c.payables+p.payables)/2)))
+    ccc = (dio or 0) + (dro or 0) - (dpo or 0)
+
+    # Ratios: (value, benchmark, higher_is_better)
+    R = [
+        ((data[-1].rev/data[0].rev)**(1/len(data))-1, 0.05, 1),  # revenue_cagr
+        (av(lambda y: d(y.gp,y.rev)), 0.05, 1),  # gross_profit_margin
+        (av(lambda y: d(y.op,y.rev)), 0.03, 1),  # operating_profit_margin
+        (av(lambda y: d(y.np_,y.rev)), 0.02, 1),  # net_profit_margin
+        (av(lambda y: d(y.np_,y.ta)), 0.07, 1),  # return_on_assets
+        (av(lambda y: d(y.np_,y.eq)), 0.13, 1),  # return_on_equity
+        (av(lambda y: d(y.ca,y.cl)), 1.2, 1),  # current_ratio
+        (av(lambda y: d(y.cash+y.recv,y.cl)), 0.9, 1),  # quick_ratio
+        (av(lambda y: d(y.cash,y.cl), [2021,2022,2023]), 0.2, 1),  # cash_ratio (3yr only)
+        (ccc, 75, 0),  # cash_conversion_cycle
+        (av2(lambda c,p: d(c.cogs,(c.inv+p.inv)/2)), 6, 1),  # inventory_turnover
+        (dio, 60, 0),  # days_inventory_outstanding
+        (av2(lambda c,p: d(c.rev,(c.recv+p.recv)/2)), 6, 1),  # receivables_turnover
+        (dro, 60, 0),  # days_receivables_outstanding
+        (av2(lambda c,p: d(c.cogs,(c.payables+p.payables)/2)), 8, 1),  # payables_turnover
+        (dpo, 45, 0),  # days_payables_outstanding
+        (av2(lambda c,p: d(c.rev,(c.wc+p.wc)/2)), 5, 1),  # working_capital_turnover
+        (av2(lambda c,p: d(c.rev,(c.ta+p.ta)/2)), 3, 1),  # total_assets_turnover
+        (av(lambda y: d(y.ltd,y.ta)), 0.25, 0),  # debt_to_total_assets
+        (av(lambda y: d(y.ltd,y.ltd+y.eq)), 0.30, 0),  # debt_to_capital
+        (av(lambda y: d(y.ltd,y.eq)), 0.50, 0),  # debt_to_equity
+        (av(lambda y: d(y.eq,y.ta)), 0.30, 1),  # equity_to_assets
+        (av(lambda y: d(y.ltd,y.ebitda)), 5, 0),  # debt_to_ebitda
+        (av(lambda y: d(y.ebitda,y.fin_cost)), 2.5, 1),  # interest_coverage
+        (av(lambda y: d(y.rel_recv,y.ca)), 0.15, 0),  # related_recv
+        (av(lambda y: d(y.rel_pay,y.cl)), 0.15, 0),  # related_pay
+        (0, 0.20, 0),  # dividend_payout
+        (av2(lambda c,p: c.sh_acct-p.sh_acct), 0, 0),  # sh_acct_cf
+        (av(lambda y: d(y.sh_acct,y.eq)), 0.30, 0),  # sh_acct_equity
+        (d(fac,L.eq), 0.10, 0),  # facility_equity
+        (d(fac,L.wc), 0.50, 0),  # facility_wc
+        (3.25+6.72*(L.op/L.ta)+1.05*(L.eq/L.tl if L.tl else 0)+6.5*(L.wc/L.ta)+3.26*(L.ret_earn/L.ta), 2.6, 1),  # altman_z
+    ]
+
+    # Score quantitative
+    qn = sum(1 for v,b,h in R if v is not None and ((v>=b) if h else (v<=b)))
+    qn_max = sum(1 for v,_,_ in R if v is not None)
+
+    # Score qualitative
+    age = 2025 - q['year_established']
+    ql = (2 if age>15 else (1 if age>=5 else -2))
+    ql += {'Small':0,'Medium':1,'Large':2}[q['size']]
+    ql += {'Low':1,'Medium':0.5,'High':0}[q['jurisdiction_risk']]
+    ql += {'Low':1,'Medium':0.5,'High':0}[q['industry_risk']]
+    ql += {'Big 4':1.5,'Mid-tier firm':1,'Regional firm':0.5,'Small practice':0}[q['auditor_quality']]
+    ql += {'Less than 1 year':0,'Between 1 and 5 years':1,'More than 5 years':2}[q['years_partnership']]
+    ql += {'Excellent':2,'Decent':0.5,'Poor':-5,'Not available':0}[q['payment_performance']]
+    ql += 0.5 if q['dnb_report']=='Yes' else 0
+    ql += 0.5 if q['kyc_cleared']=='Yes' else 0
+    ql_max = 13.5
+
+    total, mx = qn + ql, qn_max + ql_max
+    pct = total / mx
+    return total, mx, pct, 1 if pct>=.75 else (2 if pct>=.5 else (3 if pct>=.3 else 4))
+
+# TEST
+D = [FY(2020,424940890,404676036,5220334,14640,41816,23425,37419,5599501,24564704,50286283,535928,783984,300000,34456557,38854677,150000,266115,0,7687963,92507,0,15011489,64805,-20934909),
+     FY(2021,454349724,429066388,5690820,20396,80286,0,42935,3361003,42065112,81865995,769153,1170637,300000,45842790,58135783,150000,317404,0,22445666,2083192,0,19491834,71685,-32951610),
+     FY(2022,498772338,476742326,7645430,59325,67273,173444,262609,3561291,49094866,113001404,421654,1205312,300000,55158922,52584175,150000,642403,0,57708027,1003609,0,14431428,384324,-3669561),
+     FY(2023,596163040,573043229,9653846,85242,58289,50132,202673,3949339,70234333,101217024,640131,1427344,300000,68531488,42860507,150000,874103,0,62481645,2473101,0,13372566,316942,-3525486)]
+Q = {'year_established':2004,'size':'Large','jurisdiction_risk':'Medium','industry_risk':'Medium',
+     'auditor_quality':'Small practice','years_partnership':'More than 5 years',
+     'payment_performance':'Excellent','dnb_report':'Yes','kyc_cleared':'Yes'}
+
+if __name__ == "__main__":
+    t, mx, pct, tier = score(D, Q)
+    print(f"{pct:.0%}")
+    print(f"Total\\t{t}\\t{mx}")
+    print(f"Tier {tier}")
+`;
+
+export interface CreditAgentConfig {
+  model: LanguageModel;
+  member: Member;
+  conversationId: string;
+  vercelConfig: VercelConfig;
+}
+
+export async function createCreditAgent(config: CreditAgentConfig) {
+  const { model, member, conversationId, vercelConfig } = config;
+  const sandbox = await Sandbox.create({
+    token: vercelConfig.token,
+    projectId: vercelConfig.projectId,
+    teamId: vercelConfig.teamId,
+    runtime: "python3.13",
+  });
+
+  const agent = new ToolLoopAgent({
+    model,
+    instructions: `You are a credit scoring specialist with access to a credit scoring code sandbox.
+You should always fetch the data about the submissions available to you from the memory and use it to run the credit scoring code.
+
+IMPORTANT: When referencing specific data from submissions, include citation references using the format [citation:CITATION_ID] where CITATION_ID is the citationId field from the submission data. This allows users to click and view the source document.`,
+
+    tools: {
+      bash: tool({
+        description:
+          "Run bash commands in the sandbox. Use for file operations (cat, echo >), exploration (ls, find), and shell scripting.",
+        inputSchema: z.object({ command: z.string() }),
+        execute: async ({ command }) => {
+          const result = await sandbox.runCommand({
+            cmd: "bash",
+            args: ["-c", command],
+          });
+          const stdout = await result.stdout();
+          const stderr = await result.stderr();
+          return stdout || stderr;
+        },
+      }),
+      creditScoring: tool({
+        description:
+          "Run credit scoring code in the sandbox for credit scoring.",
+        inputSchema: z.object({}),
+        execute: async () => {
+          // Install numpy
+          await sandbox.runCommand({
+            cmd: "pip3",
+            args: ["install", "numpy"],
+          });
+
+          // Write both Python files using heredoc with proper newlines
+          await sandbox.runCommand({
+            cmd: "bash",
+            args: [
+              "-c",
+              `cat > credit_model.py << 'PYEOF'
+${creditScoringModelCode}
+PYEOF`,
+            ],
+          });
+          await sandbox.runCommand({
+            cmd: "bash",
+            args: [
+              "-c",
+              `cat > credit_scoring.py << 'PYEOF'
+${creditScoringRunCode}
+PYEOF`,
+            ],
+          });
+
+          const result = await sandbox.runCommand({
+            cmd: "python3",
+            args: ["credit_scoring.py"],
+          });
+
+          const stdout = await result.stdout();
+          const stderr = await result.stderr();
+
+          console.log("result:");
+          console.log(result);
+          console.log("stdout:");
+          console.log(stdout);
+          console.log("stderr:");
+          console.log(stderr);
+          console.log("--------------------------------");
+
+          return stdout || stderr;
+        },
+      }),
+      fetchSubmission: fetchSubmissionAgent({ member }),
+      createArtifact: createArtifact({ member, conversationId }),
+      updateAgentMemory: updateAgentMemory({ member, conversationId }),
+    },
+  });
+
+  return {
+    agent,
+    cleanup: async () => {
+      try {
+        await sandbox.stop();
+      } catch (err) {
+        console.error(`Failed to stop sandbox ${sandbox.sandboxId}:`, err);
+      }
+    },
+  };
+}