@securelend/sdk 0.1.0-beta.5

package/dist/index.js

@@ -0,0 +1,1004 @@
+'use strict';
+
+var zod = require('zod');
+var index_js = require('@modelcontextprotocol/sdk/client/index.js');
+var streamableHttp_js = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
+
+// src/client.ts
+
+// src/utils/errors.ts
+var SecureLendError = class extends Error {
+  constructor(message, type, details) {
+    super(message);
+    this.name = "SecureLendError";
+    this.type = type;
+    this.details = details;
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var AuthenticationError = class extends SecureLendError {
+  constructor(message) {
+    super(message, "authentication_error");
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends SecureLendError {
+  constructor(message, retryAfter) {
+    super(message, "rate_limit_error");
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ValidationError = class extends SecureLendError {
+  constructor(message, errors) {
+    super(message, "validation_error", errors);
+    this.name = "ValidationError";
+  }
+};
+var NotFoundError = class extends SecureLendError {
+  constructor(message) {
+    super(message, "not_found");
+    this.name = "NotFoundError";
+  }
+};
+var NetworkError = class extends SecureLendError {
+  constructor(message) {
+    super(message, "network_error");
+    this.name = "NetworkError";
+  }
+};
+var ServerError = class extends SecureLendError {
+  constructor(message) {
+    super(message, "server_error");
+    this.name = "ServerError";
+  }
+};
+
+// src/utils/mcp.ts
+var MCPClient = class {
+  constructor(config) {
+    this.debug = false;
+    this.isConnected = false;
+    this.config = config;
+    this.mcp = new index_js.Client({ name: "@securelend/sdk", version: "1.0.0" });
+  }
+  async connect() {
+    if (this.isConnected) return;
+    try {
+      if (this.debug) {
+        console.log(
+          `[SecureLend SDK] Connecting to MCP server at ${this.config.mcpURL}`
+        );
+      }
+      const transport = new streamableHttp_js.StreamableHTTPClientTransport(
+        new URL(this.config.mcpURL)
+      );
+      await this.mcp.connect(transport);
+      this.isConnected = true;
+      if (this.debug) {
+        console.log(`[SecureLend SDK] MCP client connected.`);
+      }
+    } catch (error) {
+      this.isConnected = false;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("401")) {
+        throw new AuthenticationError(
+          "MCP connection failed: Invalid API key."
+        );
+      }
+      throw new NetworkError(`MCP connection failed: ${errorMessage}`);
+    }
+  }
+  async callTool(name, args) {
+    await this.connect();
+    if (this.debug) {
+      console.log(`[SecureLend SDK] Calling tool: ${name} with args:`, args);
+    }
+    try {
+      const result = await this.mcp.callTool({
+        name,
+        arguments: args
+      });
+      if (this.debug) {
+        console.log(`[SecureLend SDK] Tool result for ${name}:`, result);
+      }
+      return result;
+    } catch (error) {
+      if (error instanceof SecureLendError) throw error;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("400")) {
+        throw new ValidationError("Invalid tool arguments", error);
+      }
+      throw new SecureLendError(
+        `Tool call failed: ${errorMessage}`,
+        "mcp_tool_error",
+        error
+      );
+    }
+  }
+  setApiKey(apiKey) {
+    this.config.apiKey = apiKey;
+    this.isConnected = false;
+  }
+  enableDebug() {
+    this.debug = true;
+  }
+  disableDebug() {
+    this.debug = false;
+  }
+};
+var anyObjectSchema = zod.z.object({}).passthrough();
+var CreditTier = /* @__PURE__ */ ((CreditTier2) => {
+  CreditTier2["PRIME"] = "PRIME";
+  CreditTier2["NEAR_PRIME"] = "NEAR_PRIME";
+  CreditTier2["SUBPRIME"] = "SUBPRIME";
+  CreditTier2["DEEP_SUBPRIME"] = "DEEP_SUBPRIME";
+  CreditTier2["UNKNOWN"] = "UNKNOWN";
+  return CreditTier2;
+})(CreditTier || {});
+var ProductType = /* @__PURE__ */ ((ProductType2) => {
+  ProductType2["INSTALLMENT_LOAN"] = "INSTALLMENT_LOAN";
+  ProductType2["LINE_OF_CREDIT"] = "LINE_OF_CREDIT";
+  ProductType2["SHORT_TERM_CREDIT"] = "SHORT_TERM_CREDIT";
+  ProductType2["BNPL"] = "BNPL";
+  ProductType2["MORTGAGE"] = "MORTGAGE";
+  ProductType2["AUTO_LOAN"] = "AUTO_LOAN";
+  ProductType2["AUTO_REFINANCE"] = "AUTO_REFINANCE";
+  ProductType2["STUDENT_LOAN"] = "STUDENT_LOAN";
+  ProductType2["STUDENT_LOAN_REFINANCE"] = "STUDENT_LOAN_REFINANCE";
+  ProductType2["BUSINESS_LOAN"] = "BUSINESS_LOAN";
+  ProductType2["BUSINESS_BANKING"] = "BUSINESS_BANKING";
+  ProductType2["BUSINESS_CREDIT_CARD"] = "BUSINESS_CREDIT_CARD";
+  ProductType2["PERSONAL_BANKING"] = "PERSONAL_BANKING";
+  ProductType2["SAVINGS_ACCOUNT"] = "SAVINGS_ACCOUNT";
+  ProductType2["PERSONAL_CREDIT_CARD"] = "PERSONAL_CREDIT_CARD";
+  return ProductType2;
+})(ProductType || {});
+var moneySchema = zod.z.object({
+  amount: zod.z.number(),
+  currency: zod.z.string().length(3).optional()
+});
+var bankAccountOfferSchema = zod.z.object({
+  id: zod.z.string(),
+  providerName: zod.z.string(),
+  providerLogo: zod.z.string().optional(),
+  accountName: zod.z.string(),
+  monthlyFee: zod.z.number(),
+  minBalance: zod.z.number(),
+  interestRate: zod.z.number(),
+  features: zod.z.array(zod.z.string()),
+  isSecureLendTenant: zod.z.boolean().optional(),
+  applicationUrl: zod.z.string().url().optional()
+});
+var creditCardOfferSchema = zod.z.object({
+  id: zod.z.string(),
+  issuerName: zod.z.string(),
+  issuerLogo: zod.z.string().optional(),
+  cardName: zod.z.string(),
+  apr: zod.z.object({
+    min: zod.z.number(),
+    max: zod.z.number()
+  }),
+  annualFee: zod.z.number(),
+  rewards: zod.z.object({
+    type: zod.z.enum(["cash_back", "points", "miles"]),
+    summary: zod.z.string(),
+    signupBonus: zod.z.string().optional()
+  }),
+  isSecureLendTenant: zod.z.boolean().optional(),
+  applicationUrl: zod.z.string().url().optional()
+});
+var ApplicationType = /* @__PURE__ */ ((ApplicationType2) => {
+  ApplicationType2["PERSONAL"] = "PERSONAL";
+  ApplicationType2["BUSINESS"] = "BUSINESS";
+  return ApplicationType2;
+})(ApplicationType || {});
+var ApplicationStatus = /* @__PURE__ */ ((ApplicationStatus2) => {
+  ApplicationStatus2["DRAFT"] = "DRAFT";
+  ApplicationStatus2["SUBMITTED"] = "SUBMITTED";
+  ApplicationStatus2["IN_REVIEW"] = "IN_REVIEW";
+  ApplicationStatus2["ACTION_REQUIRED"] = "ACTION_REQUIRED";
+  ApplicationStatus2["APPROVED"] = "APPROVED";
+  ApplicationStatus2["DECLINED"] = "DECLINED";
+  ApplicationStatus2["CLOSED"] = "CLOSED";
+  return ApplicationStatus2;
+})(ApplicationStatus || {});
+var ProviderStatus = /* @__PURE__ */ ((ProviderStatus2) => {
+  ProviderStatus2["PENDING"] = "PENDING";
+  ProviderStatus2["SUBMITTED"] = "SUBMITTED";
+  ProviderStatus2["REFERRED"] = "REFERRED";
+  ProviderStatus2["ERROR"] = "ERROR";
+  ProviderStatus2["RECEIVED"] = "RECEIVED";
+  return ProviderStatus2;
+})(ProviderStatus || {});
+var personalApplicantSchema = zod.z.object({
+  firstName: zod.z.string().describe("The applicant's first name."),
+  lastName: zod.z.string().describe("The applicant's last name."),
+  email: zod.z.string().email().describe("The applicant's email address."),
+  phone: zod.z.string().optional().describe("The applicant's phone number.")
+});
+var lenderSchema = zod.z.object({
+  id: zod.z.string(),
+  name: zod.z.string(),
+  type: zod.z.string(),
+  logoUrl: zod.z.string().url().optional()
+});
+var productSchema = zod.z.object({
+  name: zod.z.string(),
+  type: zod.z.string(),
+  description: zod.z.string().optional()
+});
+var loanTermsSchema = zod.z.object({
+  amount: moneySchema,
+  interestRate: zod.z.object({
+    type: zod.z.enum(["fixed", "variable"]),
+    rate: zod.z.number().optional(),
+    // rate might not always be available if only APR is given
+    apr: zod.z.number()
+  }),
+  termMonths: zod.z.number().int(),
+  payment: zod.z.object({
+    frequency: zod.z.string().optional(),
+    amount: moneySchema
+  }),
+  totalCost: moneySchema.optional(),
+  repayment: zod.z.object({
+    totalRepaymentAmount: zod.z.number(),
+    costOfFinancing: zod.z.number()
+  }).optional()
+});
+var loanFeesSchema = zod.z.object({
+  origination: zod.z.object({
+    amount: moneySchema.optional(),
+    percentage: zod.z.number().optional()
+  }).optional()
+}).optional();
+var matchingSchema = zod.z.object({
+  approvalProbability: zod.z.number().min(0).max(1).optional(),
+  matchScore: zod.z.number().min(0).max(100).optional(),
+  matchReasons: zod.z.array(zod.z.string()).optional()
+}).optional();
+var processSchema = zod.z.object({
+  applicationMethod: zod.z.string(),
+  applicationUrl: zod.z.string().url().optional(),
+  fundingSpeed: zod.z.object({
+    description: zod.z.string()
+  }).optional()
+});
+var loanOfferSchema = zod.z.object({
+  offerId: zod.z.string(),
+  lender: lenderSchema,
+  product: productSchema,
+  terms: loanTermsSchema,
+  fees: loanFeesSchema,
+  matching: matchingSchema,
+  process: processSchema.optional(),
+  // Additional fields for UI that were in the old schema
+  lenderInfo: zod.z.string().optional(),
+  badges: zod.z.array(zod.z.string()).optional(),
+  isSecureLendTenant: zod.z.boolean().optional()
+});
+var personalLoanSearchSchema = zod.z.object({
+  loanAmount: zod.z.number().min(1e3).max(1e5).describe("The desired loan amount in USD (e.g., 25000)."),
+  purpose: zod.z.enum([
+    "debt_consolidation",
+    "home_improvement",
+    "major_purchase",
+    "medical",
+    "vacation",
+    "other"
+  ]).describe("The purpose of the loan."),
+  creditScore: zod.z.number().min(300).max(850).optional().describe("The applicant's estimated credit score (300-850)."),
+  monthlyIncome: zod.z.number().min(0).optional().describe("Applicant's gross monthly income in USD."),
+  employmentStatus: zod.z.enum(["employed", "self_employed", "retired", "unemployed"]).optional().describe("The applicant's employment status."),
+  state: zod.z.string().optional().describe("The applicant's state of residence (2-letter code).")
+});
+var businessLoanSearchSchema = zod.z.object({
+  loanAmount: zod.z.number().min(1e3).describe("The desired loan amount, e.g., 50000 for $50,000."),
+  purpose: zod.z.string().describe("The reason for the loan, e.g., 'working capital'."),
+  annualRevenue: zod.z.number().min(0).optional().describe("The business's gross annual revenue in USD."),
+  industry: zod.z.string().optional().describe("The industry the business operates in, e.g., 'technology'."),
+  state: zod.z.string().optional().describe("The state where the business is located (2-letter code).")
+});
+var mortgageSearchSchema = zod.z.object({
+  loanAmount: zod.z.number().min(5e4).max(2e6).describe("The desired mortgage loan amount in USD."),
+  homePrice: zod.z.number().min(5e4).max(5e6).optional().describe("The purchase price of the home in USD."),
+  downPayment: zod.z.number().min(0).optional().describe("The amount of the down payment in USD."),
+  creditScore: zod.z.number().min(500).max(850).optional().describe("The applicant's estimated credit score (500-850)."),
+  loanType: zod.z.enum(["conventional", "fha", "va", "jumbo", "refinance"]).describe("The type of mortgage loan."),
+  propertyType: zod.z.enum(["primary", "secondary", "investment"]).optional().describe("The intended use of the property."),
+  state: zod.z.string().optional().describe("The state where the property is located (2-letter code).")
+});
+var autoLoanSearchSchema = zod.z.object({
+  loanAmount: zod.z.number().min(1e3).max(1e5).describe("The desired auto loan amount in USD."),
+  creditScore: zod.z.number().min(300).max(850).optional().describe("The applicant's estimated credit score (300-850)."),
+  isNew: zod.z.boolean().describe("Specifies if the vehicle is new (true) or used (false)."),
+  state: zod.z.string().optional().describe("The applicant's state of residence (2-letter code).")
+});
+var studentLoanSearchSchema = zod.z.object({
+  loanAmount: zod.z.number().min(1e3).max(25e4).describe("The total amount needed for the student loan in USD."),
+  creditScore: zod.z.number().min(300).max(850).optional().describe("The student's estimated credit score (300-850)."),
+  coSignerCreditScore: zod.z.number().min(300).max(850).optional().describe(
+    "The co-signer's estimated credit score (300-850), if applicable."
+  ),
+  degreeType: zod.z.enum(["undergraduate", "graduate", "mba", "medical", "law"]).describe("The type of degree the loan is for."),
+  state: zod.z.string().optional().describe("The student's state of residence (2-letter code).")
+});
+var businessCreditCardSearchSchema = zod.z.object({
+  creditScore: zod.z.number().min(300).max(850).optional().describe("The applicant's estimated credit score (300-850)."),
+  annualRevenue: zod.z.number().min(0).optional().describe("The business's annual revenue in USD."),
+  businessAgeInYears: zod.z.number().min(0).optional().describe("The age of the business in years.")
+});
+var businessCreditCardOfferSchema = zod.z.object({
+  cardId: zod.z.string(),
+  name: zod.z.string(),
+  issuer: zod.z.string(),
+  imageUrl: zod.z.string(),
+  rating: zod.z.number().min(0).max(5),
+  creditScoreRange: zod.z.string(),
+  welcomeBonus: zod.z.string(),
+  terms: zod.z.object({
+    apr: zod.z.number(),
+    annualFee: zod.z.number(),
+    creditLimit: moneySchema
+  })
+});
+var businessCreditCardComparisonResponseSchema = zod.z.object({
+  offers: zod.z.array(businessCreditCardOfferSchema),
+  searchCriteria: businessCreditCardSearchSchema.optional(),
+  metadata: zod.z.object({
+    queryId: zod.z.string(),
+    timestamp: zod.z.string(),
+    sessionId: zod.z.string().optional()
+  }),
+  widget: zod.z.string().optional()
+});
+var businessBankingSearchSchema = zod.z.object({
+  industry: zod.z.string().optional().describe("The business's industry."),
+  monthlyTransactions: zod.z.number().optional().describe("Estimated number of monthly transactions.")
+});
+var businessBankingOfferSchema = zod.z.object({
+  accountId: zod.z.string(),
+  name: zod.z.string(),
+  issuer: zod.z.string(),
+  imageUrl: zod.z.string(),
+  rating: zod.z.number().min(0).max(5),
+  bestFor: zod.z.string(),
+  apy: zod.z.string(),
+  interestRate: zod.z.string().optional(),
+  monthlyFee: zod.z.string(),
+  bonus: zod.z.string()
+});
+var businessBankingComparisonResponseSchema = zod.z.object({
+  offers: zod.z.array(businessBankingOfferSchema),
+  searchCriteria: businessBankingSearchSchema.optional(),
+  metadata: zod.z.object({
+    queryId: zod.z.string(),
+    timestamp: zod.z.string(),
+    sessionId: zod.z.string().optional()
+  }),
+  widget: zod.z.string().optional()
+});
+var personalBankingSearchSchema = zod.z.object({
+  features: zod.z.array(zod.z.string()).optional().describe("Desired account features.")
+});
+var personalBankingOfferSchema = zod.z.object({
+  accountId: zod.z.string(),
+  name: zod.z.string(),
+  issuer: zod.z.string(),
+  imageUrl: zod.z.string(),
+  rating: zod.z.number().min(0).max(5),
+  bestFor: zod.z.string(),
+  apy: zod.z.string(),
+  interestRate: zod.z.string().optional(),
+  bonus: zod.z.string(),
+  monthlyFee: zod.z.string(),
+  overdraftRating: zod.z.number().min(0).max(5)
+});
+var personalBankingComparisonResponseSchema = zod.z.object({
+  offers: zod.z.array(personalBankingOfferSchema),
+  searchCriteria: personalBankingSearchSchema.optional(),
+  metadata: zod.z.object({
+    queryId: zod.z.string(),
+    timestamp: zod.z.string(),
+    sessionId: zod.z.string().optional()
+  }),
+  widget: zod.z.string().optional()
+});
+var savingsSearchSchema = zod.z.object({
+  initialDeposit: zod.z.number().optional().describe("The initial deposit amount in USD.")
+});
+var savingsOfferSchema = zod.z.object({
+  accountId: zod.z.string(),
+  name: zod.z.string(),
+  issuer: zod.z.string(),
+  imageUrl: zod.z.string(),
+  rating: zod.z.number().min(0).max(5),
+  apy: zod.z.string(),
+  interestRate: zod.z.string().optional(),
+  minBalanceForApy: zod.z.string(),
+  monthlyFee: zod.z.string()
+});
+var savingsComparisonResponseSchema = zod.z.object({
+  offers: zod.z.array(savingsOfferSchema),
+  searchCriteria: savingsSearchSchema.optional(),
+  metadata: zod.z.object({
+    queryId: zod.z.string(),
+    timestamp: zod.z.string(),
+    sessionId: zod.z.string().optional()
+  }),
+  widget: zod.z.string().optional()
+});
+var personalCreditCardSearchSchema = zod.z.object({
+  creditScore: zod.z.number().min(300).max(850).optional().describe("The applicant's estimated credit score (300-850)."),
+  rewardsType: zod.z.enum(["cash_back", "travel", "points"]).optional().describe("Preferred rewards type.")
+});
+var personalCreditCardOfferSchema = zod.z.object({
+  cardId: zod.z.string(),
+  name: zod.z.string(),
+  issuer: zod.z.string(),
+  imageUrl: zod.z.string(),
+  rating: zod.z.number().min(0).max(5),
+  bestFor: zod.z.string(),
+  rewardsRate: zod.z.string(),
+  introOffer: zod.z.string(),
+  recommendedCreditScore: zod.z.string(),
+  terms: zod.z.object({
+    apr: zod.z.object({
+      purchase: zod.z.number(),
+      balanceTransfer: zod.z.number(),
+      penalty: zod.z.number().optional()
+    }),
+    fees: zod.z.object({
+      annual: zod.z.number()
+    })
+  }),
+  applicationUrl: zod.z.string().url().optional()
+});
+var personalCreditCardComparisonResponseSchema = zod.z.object({
+  offers: zod.z.array(personalCreditCardOfferSchema),
+  searchCriteria: personalCreditCardSearchSchema.optional(),
+  metadata: zod.z.object({
+    queryId: zod.z.string(),
+    timestamp: zod.z.string(),
+    sessionId: zod.z.string().optional()
+  }),
+  widget: zod.z.string().optional()
+});
+var loanComparisonResponseSchema = zod.z.object({
+  offers: zod.z.array(loanOfferSchema),
+  summary: zod.z.object({
+    totalOffers: zod.z.number().int(),
+    bestRate: zod.z.number(),
+    bestApprovalProbability: zod.z.number().optional(),
+    fastestFunding: zod.z.string().optional()
+  }),
+  searchCriteria: zod.z.union([
+    personalLoanSearchSchema,
+    businessLoanSearchSchema,
+    mortgageSearchSchema,
+    autoLoanSearchSchema,
+    studentLoanSearchSchema
+  ]).optional(),
+  metadata: zod.z.object({
+    queryId: zod.z.string(),
+    timestamp: zod.z.string(),
+    sessionId: zod.z.string().optional()
+  }),
+  widget: zod.z.string().optional()
+});
+var applicationProviderSchema = zod.z.object({
+  providerId: zod.z.string(),
+  providerName: zod.z.string(),
+  status: zod.z.nativeEnum(ProviderStatus),
+  submittedAt: zod.z.string().optional(),
+  providerApplicationId: zod.z.string().optional(),
+  referralUrl: zod.z.string().url().optional(),
+  error: zod.z.string().optional()
+});
+var personalApplicationSchema = zod.z.object({
+  id: zod.z.string(),
+  createdAt: zod.z.string(),
+  updatedAt: zod.z.string(),
+  applicationType: zod.z.nativeEnum(ApplicationType),
+  productType: zod.z.union([zod.z.nativeEnum(ProductType), zod.z.string()]),
+  status: zod.z.nativeEnum(ApplicationStatus),
+  applicant: personalApplicantSchema,
+  applicationData: anyObjectSchema,
+  providers: zod.z.array(applicationProviderSchema),
+  email: zod.z.string().email(),
+  widget: zod.z.string().optional()
+});
+var createPersonalApplicationSchema = zod.z.object({
+  productType: zod.z.nativeEnum(ProductType),
+  applicant: personalApplicantSchema,
+  applicationData: anyObjectSchema,
+  providers: zod.z.array(zod.z.object({ providerId: zod.z.string(), providerName: zod.z.string() })).optional()
+});
+var displayOfferFormSchema = zod.z.object({
+  sessionId: zod.z.string().optional().describe("The session ID from a previous search to retrieve all offers."),
+  offerId: zod.z.string().optional().describe("The specific offer ID to pre-select in the form.")
+});
+var anyOfferSchema = zod.z.union([
+  loanOfferSchema,
+  businessCreditCardOfferSchema,
+  businessBankingOfferSchema,
+  personalBankingOfferSchema,
+  savingsOfferSchema,
+  personalCreditCardOfferSchema
+]);
+var displayOfferFormResponseSchema = zod.z.object({
+  offer: anyOfferSchema,
+  allOffers: zod.z.array(anyOfferSchema),
+  applicationData: anyObjectSchema,
+  productType: zod.z.string(),
+  widget: zod.z.string().optional()
+});
+var getOfferSchema = zod.z.object({
+  productType: zod.z.nativeEnum(ProductType).describe("The type of financial product being applied for."),
+  applicant: personalApplicantSchema.describe(
+    "Personal details of the applicant."
+  ),
+  applicationData: anyObjectSchema.describe(
+    "The original search parameters or form data for the application."
+  ),
+  provider: zod.z.object({
+    providerId: zod.z.string().describe("The ID of the selected provider."),
+    providerName: zod.z.string().describe("The name of the selected provider.")
+  }).describe("The selected provider to submit the application to.")
+});
+var getMultipleOffersSchema = zod.z.object({
+  productType: zod.z.nativeEnum(ProductType).describe("The type of financial product being applied for."),
+  applicant: personalApplicantSchema.describe(
+    "Personal details of the applicant."
+  ),
+  applicationData: anyObjectSchema.describe(
+    "The original search parameters or form data for the application."
+  ),
+  providers: zod.z.array(
+    zod.z.object({
+      providerId: zod.z.string().describe("The ID of the selected provider."),
+      providerName: zod.z.string().describe("The name of the selected provider.")
+    })
+  ).min(1).describe("The list of selected providers to submit the application to.")
+});
+var trackOfferStatusSchema = zod.z.object({
+  applicationId: zod.z.string().optional().describe("The unique ID of the application to track."),
+  email: zod.z.string().email().optional().describe("The email address of the applicant to find applications for.")
+}).refine((data) => data.applicationId || data.email, {
+  message: "Either applicationId or email must be provided."
+});
+var trackOfferStatusResponseSchema = zod.z.object({
+  applications: zod.z.array(personalApplicationSchema),
+  widget: zod.z.string().optional()
+});
+var businessApplicantSchema = zod.z.object({
+  businessName: zod.z.string(),
+  ein: zod.z.string().optional(),
+  contact: personalApplicantSchema
+});
+var createBusinessApplicationSchema = zod.z.object({
+  productType: zod.z.nativeEnum(ProductType),
+  applicant: businessApplicantSchema,
+  applicationData: anyObjectSchema,
+  providers: zod.z.array(zod.z.object({ providerId: zod.z.string(), providerName: zod.z.string() })).optional()
+});
+var documentTypeEnum = zod.z.enum([
+  "articles-of-incorporation",
+  "balance-sheet",
+  "bank-statement",
+  "business-license",
+  "business-plan",
+  "contract",
+  "drivers-license",
+  "financial-statement",
+  "identity-document",
+  "invoice",
+  "lease-agreement",
+  "other-business-document",
+  "other-personal-document",
+  "passport",
+  "profit-and-loss-statement",
+  "proof-of-address",
+  "proof-of-income",
+  "property-document",
+  "purchase-order",
+  "tax-return",
+  "utility-bill",
+  "vehicle-document",
+  "voided-check"
+]);
+var displayUploadDocumentsFormSchema = zod.z.object({
+  applicationId: zod.z.string().optional().describe("Pre-fill the application ID for the document upload form.")
+});
+var submitDocumentsSchema = zod.z.object({
+  applicationId: zod.z.string().describe("The ID of the application to associate the document with."),
+  fileName: zod.z.string().describe("The original name of the file."),
+  documentType: documentTypeEnum.describe("The category of the document."),
+  _openai_meta: zod.z.object({}).passthrough().optional().describe("Internal metadata from OpenAI (automatically injected)")
+});
+var submitDocumentsResponseSchema = zod.z.object({
+  success: zod.z.boolean(),
+  message: zod.z.string(),
+  uploadUrl: zod.z.string().url().optional(),
+  uploadFields: zod.z.record(zod.z.string(), zod.z.string()).optional(),
+  documentId: zod.z.string().optional(),
+  widget: zod.z.string().optional()
+});
+var displayUploadDocumentsFormResponseSchema = zod.z.object({
+  widget: zod.z.string().optional()
+});
+var loanPaymentSchema = zod.z.object({
+  loanAmount: zod.z.number().describe("The total amount of the loan in USD.").positive("Loan amount must be positive."),
+  interestRate: zod.z.number().describe("The annual interest rate (e.g., 5 for 5%).").min(0, "Interest rate cannot be negative."),
+  loanTermInMonths: zod.z.number().describe("The duration of the loan in months.").positive("Loan term must be positive.").int()
+});
+var loanPaymentResponseSchema = zod.z.object({
+  monthlyPayment: zod.z.number().describe("The calculated monthly payment amount."),
+  totalPayment: zod.z.number().describe("The total amount to be paid over the life of the loan."),
+  totalInterest: zod.z.number().describe("The total interest paid over the life of the loan."),
+  widget: zod.z.string().optional()
+});
+var mortgagePaymentSchema = zod.z.object({
+  propertyValue: zod.z.number().describe("The total value of the property in USD.").positive("Property value must be positive."),
+  downPayment: zod.z.number().describe("The amount paid upfront in USD.").min(0, "Down payment cannot be negative."),
+  interestRate: zod.z.number().describe("The annual interest rate (e.g., 3.5 for 3.5%).").min(0, "Interest rate cannot be negative."),
+  loanTermInYears: zod.z.number().describe("The duration of the loan in years.").positive("Loan term must be positive.").int(),
+  propertyTaxRate: zod.z.number().describe(
+    "The annual property tax rate as a percentage (e.g., 1.2 for 1.2%)."
+  ).min(0, "Property tax rate cannot be negative."),
+  homeInsurance: zod.z.number().describe("The annual home insurance cost in USD.").min(0, "Home insurance cannot be negative.")
+});
+var mortgagePaymentResponseSchema = zod.z.object({
+  loanAmount: zod.z.number().describe("The total loan amount after down payment."),
+  principalAndInterest: zod.z.number().describe("The monthly payment for principal and interest."),
+  monthlyPropertyTax: zod.z.number().describe("The estimated monthly property tax payment."),
+  monthlyHomeInsurance: zod.z.number().describe("The estimated monthly home insurance payment."),
+  totalMonthlyPayment: zod.z.number().describe("The total estimated monthly payment (PITI)."),
+  widget: zod.z.string().optional()
+});
+var leaseVsPurchaseSchema = zod.z.object({
+  // Purchase details
+  purchasePrice: zod.z.number().positive("Purchase price must be positive.").describe("Total price of the vehicle for purchase in USD."),
+  downPayment: zod.z.number().min(0, "Down payment cannot be negative.").describe("Upfront payment amount for purchase in USD."),
+  loanTermInMonths: zod.z.number().positive().int().describe("Loan duration in months for purchase."),
+  interestRate: zod.z.number().min(0, "Interest rate cannot be negative.").describe("Annual interest rate for purchase loan (e.g., 5 for 5%)."),
+  salesTaxRate: zod.z.number().min(0, "Sales tax rate cannot be negative.").describe("Sales tax rate as a percentage (e.g., 7.5 for 7.5%)."),
+  // Lease details
+  leaseTermInMonths: zod.z.number().positive().int().describe("Lease duration in months."),
+  monthlyLeasePayment: zod.z.number().positive().describe("Monthly payment for the lease in USD."),
+  moneyFactor: zod.z.number().positive("Money factor must be positive.").describe("The money factor for the lease (similar to interest rate)."),
+  acquisitionFee: zod.z.number().min(0).default(0).describe("Fee charged by the lessor to initiate the lease in USD."),
+  securityDeposit: zod.z.number().min(0).default(0).describe("Refundable deposit paid at the start of the lease in USD."),
+  // Common details
+  residualValuePercentage: zod.z.number().min(0).max(100, "Residual value percentage cannot exceed 100.").describe(
+    "Estimated value of the vehicle at the end of the lease, as a percentage of MSRP."
+  ),
+  expectedOwnershipInMonths: zod.z.number().positive().int().describe("How long you plan to keep the vehicle, in months.")
+});
+var leaseVsPurchaseResponseSchema = zod.z.object({
+  purchaseAnalysis: zod.z.object({
+    totalLoanPayment: zod.z.number(),
+    totalInterestPaid: zod.z.number(),
+    totalSalesTax: zod.z.number(),
+    equityAfterOwnership: zod.z.number(),
+    totalCostOfOwnership: zod.z.number(),
+    monthlyPayment: zod.z.number()
+  }),
+  leaseAnalysis: zod.z.object({
+    totalLeasePayments: zod.z.number(),
+    totalUpfrontCosts: zod.z.number(),
+    totalCostOfLeasing: zod.z.number()
+  }),
+  comparison: zod.z.object({
+    purchaseCostIsLowerBy: zod.z.number(),
+    leaseCostIsLowerBy: zod.z.number(),
+    recommendation: zod.z.string()
+  }),
+  widget: zod.z.string().optional()
+});
+
+// src/client.ts
+var SecureLend = class {
+  /**
+   * Create a new SecureLend client
+   *
+   * @param config - Optional configuration
+   */
+  constructor(config) {
+    let mcpURL = config?.serverUrl || "https://mcp.securelend.ai/mcp";
+    if (typeof window !== "undefined" && mcpURL.startsWith("/")) {
+      mcpURL = window.location.origin + mcpURL;
+    }
+    this.mcpClient = new MCPClient({ apiKey: config?.apiKey || "", mcpURL });
+    this.mcp = this.mcpClient.mcp;
+  }
+  // --- Loan Comparison ---
+  async comparePersonalLoans(request) {
+    return this.callTool(
+      "compare_personal_loans",
+      request,
+      loanComparisonResponseSchema
+    );
+  }
+  async compareBusinessLoans(request) {
+    return this.callTool(
+      "compare_business_loans",
+      request,
+      loanComparisonResponseSchema
+    );
+  }
+  async comparePersonalMortgages(request) {
+    return this.callTool(
+      "compare_personal_mortgages",
+      request,
+      loanComparisonResponseSchema
+    );
+  }
+  async compareBusinessMortgages(request) {
+    return this.callTool(
+      "compare_business_mortgages",
+      request,
+      loanComparisonResponseSchema
+    );
+  }
+  async compareCarLoans(request) {
+    return this.callTool(
+      "compare_car_loans",
+      request,
+      loanComparisonResponseSchema
+    );
+  }
+  async compareStudentLoans(request) {
+    return this.callTool(
+      "compare_student_loans",
+      request,
+      loanComparisonResponseSchema
+    );
+  }
+  // --- Banking & Credit Cards ---
+  async compareBusinessBanking(request) {
+    return this.callTool(
+      "compare_business_banking",
+      request,
+      businessBankingComparisonResponseSchema
+    );
+  }
+  async comparePersonalBanking(request) {
+    return this.callTool(
+      "compare_personal_banking",
+      request,
+      personalBankingComparisonResponseSchema
+    );
+  }
+  async compareSavingsAccounts(request) {
+    return this.callTool(
+      "compare_savings_accounts",
+      request,
+      savingsComparisonResponseSchema
+    );
+  }
+  async compareBusinessCreditCards(request) {
+    return this.callTool(
+      "compare_business_credit_cards",
+      request,
+      businessCreditCardComparisonResponseSchema
+    );
+  }
+  async comparePersonalCreditCards(request) {
+    return this.callTool(
+      "compare_personal_credit_cards",
+      request,
+      personalCreditCardComparisonResponseSchema
+    );
+  }
+  // --- Financial Calculators ---
+  async calculateLoanPayment(request) {
+    return this.callTool(
+      "calculate_loan_payment",
+      request,
+      loanPaymentResponseSchema
+    );
+  }
+  async calculateMortgagePayment(request) {
+    return this.callTool(
+      "calculate_mortgage_payment",
+      request,
+      mortgagePaymentResponseSchema
+    );
+  }
+  async compareLeaseVsPurchase(request) {
+    return this.callTool(
+      "compare_lease_vs_purchase",
+      request,
+      leaseVsPurchaseResponseSchema
+    );
+  }
+  // --- Application Management ---
+  async getOffer(request) {
+    return this.callTool("get_offer", request, personalApplicationSchema);
+  }
+  async getMultipleOffers(request) {
+    return this.callTool(
+      "get_multiple_offers",
+      request,
+      personalApplicationSchema
+    );
+  }
+  async displayOfferForm(request) {
+    return this.callTool(
+      "display_offer_form",
+      request,
+      displayOfferFormResponseSchema
+    );
+  }
+  async trackOfferStatus(request) {
+    return this.callTool(
+      "track_offer_status",
+      request,
+      trackOfferStatusResponseSchema
+    );
+  }
+  async displayUploadDocumentsForm(request) {
+    return this.callTool(
+      "display_upload_documents_form",
+      request,
+      displayUploadDocumentsFormResponseSchema
+    );
+  }
+  async submitDocuments(request) {
+    return this.callTool(
+      "submit_documents",
+      request,
+      submitDocumentsResponseSchema
+    );
+  }
+  // --- Core Methods ---
+  /**
+   * Manually connect to the MCP server.
+   * Connection is otherwise established on the first tool call.
+   */
+  async connect() {
+    await this.mcpClient.connect();
+  }
+  /**
+   * Enable debug logging
+   */
+  enableDebug() {
+    this.mcpClient.enableDebug();
+  }
+  /**
+   * Disable debug logging
+   */
+  disableDebug() {
+    this.mcpClient.disableDebug();
+  }
+  /**
+   * Set the API key for subsequent requests.
+   * @param apiKey - The new API key
+   */
+  setApiKey(apiKey) {
+    this.mcpClient.setApiKey(apiKey);
+  }
+  // --- Private Helpers ---
+  async callTool(toolName, request, schema) {
+    const toolResult = await this.mcpClient.callTool(
+      toolName,
+      request
+    );
+    const data = this.parseJsonResponse(toolResult, schema);
+    return { ...data, widget: this.getWidget(toolResult) };
+  }
+  parseJsonResponse(toolResult, schema) {
+    try {
+      let jsonData;
+      if (toolResult.structuredContent) {
+        jsonData = toolResult.structuredContent;
+      } else {
+        const jsonContent = toolResult.content.find(
+          (c) => c.type === "resource" && c.resource && c.resource.mimeType === "application/json" || c.type === "text"
+        );
+        if (!jsonContent) {
+          throw new SecureLendError(
+            "Invalid response from MCP server: missing JSON content",
+            "mcp_error",
+            toolResult
+          );
+        }
+        if (jsonContent.type === "text" && jsonContent.text) {
+          jsonData = JSON.parse(jsonContent.text);
+        } else if (jsonContent.type === "resource" && jsonContent.resource) {
+          jsonData = JSON.parse(jsonContent.resource.text);
+        } else {
+          throw new Error("Invalid content structure");
+        }
+      }
+      return schema.parse(jsonData);
+    } catch (e) {
+      if (e instanceof zod.z.ZodError) {
+        throw new ValidationError(
+          "Invalid response from MCP server: failed to validate JSON content",
+          { validationErrors: e.issues, serverResponse: toolResult }
+        );
+      }
+      throw new SecureLendError(
+        "Invalid response from MCP server: failed to parse JSON content",
+        "mcp_error",
+        { originalError: e, serverResponse: toolResult }
+      );
+    }
+  }
+  getWidget(toolResult) {
+    const widgetContent = toolResult.content.find(
+      (c) => c.type === "resource" && c.resource?.mimeType === "text/html"
+    );
+    if (widgetContent?.type === "resource" && widgetContent.resource) {
+      return widgetContent.resource.text;
+    }
+    return void 0;
+  }
+};
+
+exports.ApplicationStatus = ApplicationStatus;
+exports.ApplicationType = ApplicationType;
+exports.AuthenticationError = AuthenticationError;
+exports.CreditTier = CreditTier;
+exports.NetworkError = NetworkError;
+exports.NotFoundError = NotFoundError;
+exports.ProductType = ProductType;
+exports.ProviderStatus = ProviderStatus;
+exports.RateLimitError = RateLimitError;
+exports.SecureLend = SecureLend;
+exports.SecureLendError = SecureLendError;
+exports.ServerError = ServerError;
+exports.ValidationError = ValidationError;
+exports.anyOfferSchema = anyOfferSchema;
+exports.applicationProviderSchema = applicationProviderSchema;
+exports.autoLoanSearchSchema = autoLoanSearchSchema;
+exports.bankAccountOfferSchema = bankAccountOfferSchema;
+exports.businessApplicantSchema = businessApplicantSchema;
+exports.businessBankingComparisonResponseSchema = businessBankingComparisonResponseSchema;
+exports.businessBankingOfferSchema = businessBankingOfferSchema;
+exports.businessBankingSearchSchema = businessBankingSearchSchema;
+exports.businessCreditCardComparisonResponseSchema = businessCreditCardComparisonResponseSchema;
+exports.businessCreditCardOfferSchema = businessCreditCardOfferSchema;
+exports.businessCreditCardSearchSchema = businessCreditCardSearchSchema;
+exports.businessLoanSearchSchema = businessLoanSearchSchema;
+exports.createBusinessApplicationSchema = createBusinessApplicationSchema;
+exports.createPersonalApplicationSchema = createPersonalApplicationSchema;
+exports.creditCardOfferSchema = creditCardOfferSchema;
+exports.displayOfferFormResponseSchema = displayOfferFormResponseSchema;
+exports.displayOfferFormSchema = displayOfferFormSchema;
+exports.displayUploadDocumentsFormResponseSchema = displayUploadDocumentsFormResponseSchema;
+exports.displayUploadDocumentsFormSchema = displayUploadDocumentsFormSchema;
+exports.documentTypeEnum = documentTypeEnum;
+exports.getMultipleOffersSchema = getMultipleOffersSchema;
+exports.getOfferSchema = getOfferSchema;
+exports.leaseVsPurchaseResponseSchema = leaseVsPurchaseResponseSchema;
+exports.leaseVsPurchaseSchema = leaseVsPurchaseSchema;
+exports.loanComparisonResponseSchema = loanComparisonResponseSchema;
+exports.loanOfferSchema = loanOfferSchema;
+exports.loanPaymentResponseSchema = loanPaymentResponseSchema;
+exports.loanPaymentSchema = loanPaymentSchema;
+exports.mortgagePaymentResponseSchema = mortgagePaymentResponseSchema;
+exports.mortgagePaymentSchema = mortgagePaymentSchema;
+exports.mortgageSearchSchema = mortgageSearchSchema;
+exports.personalApplicantSchema = personalApplicantSchema;
+exports.personalApplicationSchema = personalApplicationSchema;
+exports.personalBankingComparisonResponseSchema = personalBankingComparisonResponseSchema;
+exports.personalBankingOfferSchema = personalBankingOfferSchema;
+exports.personalBankingSearchSchema = personalBankingSearchSchema;
+exports.personalCreditCardComparisonResponseSchema = personalCreditCardComparisonResponseSchema;
+exports.personalCreditCardOfferSchema = personalCreditCardOfferSchema;
+exports.personalCreditCardSearchSchema = personalCreditCardSearchSchema;
+exports.personalLoanSearchSchema = personalLoanSearchSchema;
+exports.savingsComparisonResponseSchema = savingsComparisonResponseSchema;
+exports.savingsOfferSchema = savingsOfferSchema;
+exports.savingsSearchSchema = savingsSearchSchema;
+exports.studentLoanSearchSchema = studentLoanSearchSchema;
+exports.submitDocumentsResponseSchema = submitDocumentsResponseSchema;
+exports.submitDocumentsSchema = submitDocumentsSchema;
+exports.trackOfferStatusResponseSchema = trackOfferStatusResponseSchema;
+exports.trackOfferStatusSchema = trackOfferStatusSchema;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map