@falai/agent 0.6.0 → 0.6.2

package/docs/ADAPTERS.md

@@ -4,6 +4,18 @@ All adapters follow the **provider pattern** - no dependencies required in the p
 
 **NEW**: All adapters now support the new **Session State** pattern with automatic persistence of extracted data, current route/state, and conversation progress!
 
+### 🎯 Available Adapters
+
+| Adapter               | Use Case                           | Install                                      |
+| --------------------- | ---------------------------------- | -------------------------------------------- |
+| **PrismaAdapter**     | Type-safe ORM with migrations      | `npm install @prisma/client`                 |
+| **RedisAdapter**      | Fast in-memory for real-time apps  | `npm install ioredis`                        |
+| **MongoAdapter**      | Flexible document storage          | `npm install mongodb`                        |
+| **PostgreSQLAdapter** | Raw SQL with auto table creation   | `npm install pg`                             |
+| **SQLiteAdapter**     | Lightweight local database         | `npm install better-sqlite3`                 |
+| **OpenSearchAdapter** | Full-text search & analytics       | `npm install @opensearch-project/opensearch` |
+| **MemoryAdapter**     | Testing & development (no install) | Built-in (no dependencies) ✨                |
+
 ## ✅ Implemented Adapters
 
 ### 1. **PrismaAdapter**

package/docs/DOCS.md

@@ -0,0 +1,239 @@
+# Documentation Index
+
+Complete index of all `@falai/agent` documentation.
+
+---
+
+## 🚀 Getting Started
+
+Start here if you're new to the framework:
+
+### [Getting Started Guide](./GETTING_STARTED.md)
+Build your first AI agent in 5 minutes with step-by-step instructions.
+
+**Topics:** Installation, first agent, basic routes, data extraction, session state
+
+---
+
+## 📖 Core Concepts
+
+Essential guides for understanding how the framework works:
+
+### [Architecture](./ARCHITECTURE.md)
+Design principles, philosophy, and how the framework works under the hood.
+
+**Topics:** Schema-first extraction, session state, code-based logic, state machines, deterministic IDs
+
+### [Constructor Options](./CONSTRUCTOR_OPTIONS.md)
+Comprehensive guide to agent configuration patterns.
+
+**Topics:** Declarative vs fluent API, terms, guidelines, capabilities, routes, initialization patterns
+
+### [Context Management](./CONTEXT_MANAGEMENT.md)
+Session state, lifecycle hooks, and persistent conversations.
+
+**Topics:** Session state, lifecycle hooks, context updates, multi-turn conversations, persistence patterns
+
+---
+
+## 🔧 Feature Guides
+
+Deep dives into specific features:
+
+### [API Reference](./API_REFERENCE.md)
+Complete API documentation for all classes, methods, and types.
+
+**Topics:** Agent class, Route class, State class, defineTool, providers, all APIs
+
+### [AI Providers](./PROVIDERS.md)
+Guide to AI provider configuration and usage.
+
+**Topics:** Anthropic (Claude), OpenAI (GPT), Google (Gemini), OpenRouter, custom providers, backup models, retry logic
+
+### [Domain Organization](./DOMAINS.md)
+Optional tool security and organization.
+
+**Topics:** Domain-based security, tool scoping, route isolation, preventing unauthorized access
+
+### [Persistence Guide](./PERSISTENCE.md)
+Database integration and session persistence.
+
+**Topics:** Persistence adapters, auto-save, session management, lifecycle integration, custom adapters
+
+### [Database Adapters](./ADAPTERS.md)
+Detailed comparison and configuration for all database adapters.
+
+**Topics:** Prisma, Redis, MongoDB, PostgreSQL, SQLite, OpenSearch, Memory adapter, custom adapters
+
+---
+
+## 💡 Examples & Patterns
+
+Real-world code examples:
+
+### [Examples Guide](./EXAMPLES.md)
+Comprehensive guide to all 15+ production-ready examples.
+
+**Topics:** Learning path, use case guide, code examples, quick reference
+
+### [Example Files](../examples/)
+Browse the `/examples` directory for runnable code:
+- [Business Onboarding](../examples/business-onboarding.ts) - Complex multi-step workflows
+- [Travel Agent](../examples/travel-agent.ts) - Session state & data extraction
+- [Healthcare Agent](../examples/healthcare-agent.ts) - Security & validation
+- [Streaming Agent](../examples/streaming-agent.ts) - Real-time responses
+- [Prisma Persistence](../examples/prisma-persistence.ts) - Database integration
+- [Domain Scoping](../examples/domain-scoping.ts) - Tool security
+- [And 10+ more...](./EXAMPLES.md)
+
+---
+
+## 🤝 Contributing
+
+Help improve the framework:
+
+### [Contributing Guide](./CONTRIBUTING.md)
+How to contribute code, documentation, and report issues.
+
+**Topics:** Development setup, code style, pull requests, bug reports
+
+### [Publishing Guide](./PUBLISHING.md)
+Internal guide for maintainers on publishing releases.
+
+**Topics:** Release process, versioning, npm publishing, changelog
+
+---
+
+## 📚 Quick Reference
+
+### By Use Case
+
+**I want to...**
+
+- **Build my first agent** → [Getting Started](./GETTING_STARTED.md)
+- **Understand the design** → [Architecture](./ARCHITECTURE.md)
+- **Configure my agent** → [Constructor Options](./CONSTRUCTOR_OPTIONS.md)
+- **Persist conversations** → [Persistence Guide](./PERSISTENCE.md)
+- **Add tool security** → [Domain Organization](./DOMAINS.md)
+- **See real examples** → [Examples Guide](./EXAMPLES.md)
+- **Look up an API** → [API Reference](./API_REFERENCE.md)
+- **Use a different AI provider** → [AI Providers](./PROVIDERS.md)
+- **Choose a database** → [Database Adapters](./ADAPTERS.md)
+- **Contribute code** → [Contributing Guide](./CONTRIBUTING.md)
+
+### By Topic
+
+**Architecture & Design:**
+- [Architecture Guide](./ARCHITECTURE.md)
+- [How It Works](../README.md#-how-it-works)
+
+**Agent Configuration:**
+- [Constructor Options](./CONSTRUCTOR_OPTIONS.md)
+- [Context Management](./CONTEXT_MANAGEMENT.md)
+- [Getting Started](./GETTING_STARTED.md)
+
+**Routes & State Machines:**
+- [API Reference - Routes](./API_REFERENCE.md#route)
+- [Architecture - State Machines](./ARCHITECTURE.md#state-machines)
+- [Examples - Complex Flows](./EXAMPLES.md#-real-world-applications)
+
+**Tools & Domains:**
+- [Domain Organization](./DOMAINS.md)
+- [API Reference - defineTool](./API_REFERENCE.md#definetool)
+- [Examples - Domain Scoping](./EXAMPLES.md#-domain-scoping)
+
+**Data Extraction:**
+- [Architecture - Schema-First](./ARCHITECTURE.md#schema-first-data-extraction)
+- [API Reference - extractionSchema](./API_REFERENCE.md#extractionschema)
+- [Examples - Travel Agent](./EXAMPLES.md#-travel-agent)
+
+**Session State:**
+- [Context Management](./CONTEXT_MANAGEMENT.md)
+- [Architecture - Session State](./ARCHITECTURE.md#session-state-management)
+- [API Reference - createSession](./API_REFERENCE.md#createsession)
+
+**Persistence:**
+- [Persistence Guide](./PERSISTENCE.md)
+- [Database Adapters](./ADAPTERS.md)
+- [Examples - Prisma](./EXAMPLES.md#-prisma-persistence)
+
+**AI Providers:**
+- [AI Providers Guide](./PROVIDERS.md)
+- [API Reference - Providers](./API_REFERENCE.md#providers)
+- [Examples - Multiple Providers](./EXAMPLES.md#-provider-examples)
+
+**Streaming:**
+- [API Reference - respondStream](./API_REFERENCE.md#respondstream)
+- [Examples - Streaming](./EXAMPLES.md#-streaming-responses)
+
+---
+
+## 📖 Documentation Format Guide
+
+All documentation follows these conventions:
+
+### Code Examples
+All code examples are TypeScript and can be copy-pasted directly.
+
+### Links
+- Internal docs use relative links: `[Text](./FILE.md)`
+- Examples use relative links: `[Text](../examples/file.ts)`
+- External links use full URLs
+
+### File Structure
+```
+docs/
+├── INDEX.md              # This file - documentation index
+├── README.md             # Docs overview and quick links
+├── GETTING_STARTED.md    # Beginner tutorial
+├── ARCHITECTURE.md       # Design principles
+├── API_REFERENCE.md      # Complete API docs
+├── CONSTRUCTOR_OPTIONS.md # Configuration patterns
+├── CONTEXT_MANAGEMENT.md # Session state & hooks
+├── PERSISTENCE.md        # Database integration
+├── ADAPTERS.md          # Database adapter guide
+├── DOMAINS.md           # Tool security
+├── PROVIDERS.md         # AI provider guide
+├── EXAMPLES.md          # Examples guide
+├── CONTRIBUTING.md      # How to contribute
+└── PUBLISHING.md        # Release guide (maintainers)
+```
+
+---
+
+## 🔍 Search Tips
+
+**Looking for something specific?**
+
+1. **Check this index first** for the right doc
+2. **Use your browser's find** (Ctrl+F / Cmd+F) within docs
+3. **Check the [Examples Guide](./EXAMPLES.md)** for code samples
+4. **Search the [API Reference](./API_REFERENCE.md)** for specific APIs
+
+**Common searches:**
+- "How do I..." → [Getting Started](./GETTING_STARTED.md)
+- "What is..." → [Architecture](./ARCHITECTURE.md)
+- "Example of..." → [Examples Guide](./EXAMPLES.md)
+- "API for..." → [API Reference](./API_REFERENCE.md)
+
+---
+
+## 📱 External Resources
+
+- **Main Website:** [falai.dev](https://falai.dev)
+- **GitHub Repository:** [github.com/gusnips/falai](https://github.com/gusnips/falai)
+- **npm Package:** [@falai/agent](https://www.npmjs.com/package/@falai/agent)
+- **Issue Tracker:** [GitHub Issues](https://github.com/gusnips/falai/issues)
+
+---
+
+## 🆘 Still Can't Find What You Need?
+
+1. **Check the [main README](../README.md)** for an overview
+2. **Browse [all examples](../examples/)** for code patterns
+3. **Search [closed issues](https://github.com/gusnips/falai/issues?q=is%3Aissue+is%3Aclosed)** for similar questions
+4. **Open a [new issue](https://github.com/gusnips/falai/issues/new)** with your question
+
+---
+
+**Last Updated:** 2025-10-15

package/docs/EXAMPLES.md

@@ -0,0 +1,419 @@
+# Examples
+
+This directory contains production-ready examples demonstrating all features of `@falai/agent`.
+
+## 🚀 Getting Started Examples
+
+### 📋 [Declarative Agent](../examples/declarative-agent.ts)
+
+**Perfect for:** Learning the full configuration API
+
+Comprehensive example showing declarative agent configuration:
+
+- ✅ Full constructor-based setup
+- ✅ Terms, guidelines, capabilities, routes defined upfront
+- ✅ Session state management with data extraction
+- ✅ Custom IDs for routes, states, and tools
+- ✅ Dynamic additions after construction
+
+**Key concepts:** Declarative configuration, session state, data extraction schemas
+
+```typescript
+const agent = new Agent({
+  name: "HealthBot",
+  ai: provider,
+  terms: [...],
+  guidelines: [...],
+  routes: [{
+    extractionSchema: { /* JSON Schema */ }
+  }]
+});
+```
+
+---
+
+## 🏢 Real-World Applications
+
+### 🏢 [Business Onboarding](../examples/business-onboarding.ts)
+
+**Perfect for:** Building complex multi-step workflows
+
+Production-ready business onboarding with advanced patterns:
+
+- ✅ Multi-step data collection flow
+- ✅ Branching logic (physical vs online business)
+- ✅ Tools with `contextUpdate` for automatic state management
+- ✅ Both step-by-step and fluent chaining approaches
+- ✅ Lifecycle hooks for persistence
+- ✅ Dynamic route creation based on collected data
+
+**Key concepts:** Complex flows, branching logic, context updates, lifecycle hooks
+
+```typescript
+// Branching based on business type
+const askPhysicalLocation = askLocation.transitionTo({
+  chatState: "Get physical store address",
+  condition: "User has a physical store",
+});
+
+const askOnlineLocation = askLocation.transitionTo({
+  chatState: "Get website and online support hours",
+  condition: "User does not have a physical store",
+});
+```
+
+### ✈️ [Travel Agent](../examples/travel-agent.ts)
+
+**Perfect for:** Multi-route systems with session state
+
+Complete travel booking system featuring:
+
+- ✅ Multi-step flight booking flow
+- ✅ Data extraction with JSON Schema
+- ✅ Session state tracking across turns
+- ✅ Tools with data access via `extracted` context
+- ✅ Alternative flow handling (booking vs status check)
+- ✅ Route-specific guidelines
+
+**Key concepts:** Session state, data extraction, multiple routes, tool data access
+
+```typescript
+const searchFlights = defineTool(
+  "search_flights",
+  async ({ context, extracted }) => {
+    // Tool has access to extracted booking data
+    if (!extracted?.destination || !extracted?.departureDate) {
+      return { data: [] };
+    }
+    // Use extracted data to search
+    const flights = await searchAPI(extracted);
+    return { data: flights };
+  }
+);
+```
+
+### 🏥 [Healthcare Assistant](../examples/healthcare-agent.ts)
+
+**Perfect for:** Sensitive data handling and compliance
+
+Healthcare-focused agent demonstrating:
+
+- ✅ Appointment scheduling with validation
+- ✅ Lab results retrieval
+- ✅ Route-based disambiguation with conditions
+- ✅ Sensitive data handling best practices
+- ✅ Urgent case prioritization
+- ✅ HIPAA-style security patterns
+
+**Key concepts:** Data security, route disambiguation, validation, compliance
+
+---
+
+## ⚡ Advanced Features
+
+### ⚡ [Streaming Responses](../examples/streaming-agent.ts)
+
+**Perfect for:** Real-time UX and better perceived performance
+
+Real-time streaming responses:
+
+- ✅ Stream responses from all providers (Anthropic, OpenAI, Gemini, OpenRouter)
+- ✅ Real-time text generation with `respondStream`
+- ✅ Cancellable streams with AbortSignal
+- ✅ Access route, state, and tool information in final chunk
+- ✅ 5 comprehensive examples covering different use cases
+
+**Key concepts:** Streaming, real-time UX, cancellation
+
+```typescript
+for await (const chunk of agent.respondStream({ history })) {
+  process.stdout.write(chunk.delta);
+
+  if (chunk.done) {
+    console.log("Route:", chunk.route?.title);
+    console.log("Extracted:", chunk.extracted);
+  }
+}
+```
+
+### 🔐 [Domain Scoping](../examples/domain-scoping.ts)
+
+**Perfect for:** Security-conscious applications
+
+Control tool access per route for security:
+
+- ✅ Organize tools into security domains
+- ✅ Restrict which tools each route can use
+- ✅ Prevent unauthorized tool calls
+- ✅ Improve AI performance by reducing decision space
+- ✅ Clear documentation of route capabilities
+
+**Key concepts:** Security, tool isolation, domain organization
+
+```typescript
+agent.addDomain("payment", { processPayment, refund });
+agent.addDomain("user", { updateProfile, sendEmail });
+
+// Checkout route can ONLY use payment tools
+agent.createRoute({
+  title: "Checkout",
+  domains: ["payment"], // ← Security boundary
+});
+```
+
+### 📜 [Rules & Prohibitions](../examples/rules-prohibitions.ts)
+
+**Perfect for:** Multi-channel bots with different styles
+
+Control agent behavior and communication style per route:
+
+- ✅ Define absolute rules the agent must follow
+- ✅ Set prohibitions for what agent must never do
+- ✅ Different communication styles per route
+- ✅ Perfect for multi-channel bots (WhatsApp, email, chat)
+- ✅ Automatic enforcement without manual checking
+
+**Key concepts:** Behavior control, tone management, channel-specific styling
+
+```typescript
+agent.createRoute({
+  title: "WhatsApp Support",
+  rules: ["Keep messages under 2 lines", "Use max 1 emoji"],
+  prohibitions: ["Never send long paragraphs", "Don't over-explain"],
+});
+
+agent.createRoute({
+  title: "Email Support",
+  rules: ["Use professional tone", "Include clear next steps"],
+  prohibitions: ["No emojis", "Avoid slang"],
+});
+```
+
+---
+
+## 💾 Persistence Examples
+
+### 💾 [Prisma Persistence](../examples/prisma-persistence.ts)
+
+**Perfect for:** Production apps with relational databases
+
+Auto-save sessions and messages with Prisma ORM:
+
+- ✅ Provider pattern - simple as `new PrismaAdapter({ prisma })`
+- ✅ Automatic session and message persistence
+- ✅ Seamless lifecycle hook integration
+- ✅ Type-safe database operations
+- ✅ 3-step setup guide
+
+**Key concepts:** Database persistence, Prisma ORM, auto-save
+
+```typescript
+const agent = new Agent({
+  persistence: {
+    adapter: new PrismaAdapter({ prisma }),
+    autoSave: true,
+    userId: "user_123",
+  },
+});
+```
+
+### ⚡ [Redis Persistence](../examples/redis-persistence.ts)
+
+**Perfect for:** High-throughput real-time applications
+
+Fast, in-memory persistence:
+
+- ✅ Lightning-fast session storage
+- ✅ Configurable TTLs for auto-cleanup
+- ✅ Custom key prefixes
+- ✅ Perfect for real-time chat applications
+- ✅ Simple setup with ioredis
+
+**Key concepts:** In-memory persistence, Redis, TTL management
+
+### 🔍 [OpenSearch Persistence](../examples/opensearch-persistence.ts)
+
+**Perfect for:** Analytics and full-text search requirements
+
+Full-text search and analytics-powered persistence:
+
+- ✅ Built-in full-text search across all messages
+- ✅ Powerful aggregations and analytics
+- ✅ Compatible with Elasticsearch 7.x
+- ✅ AWS OpenSearch Service ready
+- ✅ Index management and optimization
+
+**Key concepts:** Search, analytics, OpenSearch, Elasticsearch
+
+### 🗄️ [Custom Database Integration](../examples/custom-database-persistence.ts)
+
+**Perfect for:** Integrating with existing database schemas
+
+Manual session state management for existing schemas:
+
+- ✅ Full control over database operations
+- ✅ Works with any database (no adapter needed)
+- ✅ Manual session state save/restore
+- ✅ Perfect for integrating with existing schemas
+- ✅ Complete example with validation hooks
+
+**Key concepts:** Custom persistence, existing schemas, manual control
+
+---
+
+## 🔧 Context & State Management
+
+### 💾 [Persistent Onboarding Agent](../examples/persistent-onboarding.ts)
+
+**Perfect for:** Multi-turn conversations with persistence
+
+Multi-turn conversation with state persistence:
+
+- ✅ Context lifecycle hooks for database integration
+- ✅ Automatic persistence on context updates
+- ✅ Factory pattern for agent creation
+- ✅ Two approaches: lifecycle hooks vs context provider
+- ✅ Complete onboarding flow across multiple turns
+
+**Key concepts:** Context lifecycle, multi-turn conversations, factory pattern
+
+```typescript
+const agent = new Agent({
+  hooks: {
+    beforeRespond: async (context) => {
+      return await database.loadContext(sessionId);
+    },
+    onContextUpdate: async (newContext) => {
+      await database.saveContext(sessionId, newContext);
+    },
+  },
+});
+```
+
+### 🔄 [Extracted Data Modification](../examples/extracted-data-modification.ts)
+
+**Perfect for:** Data validation and enrichment
+
+Tools that validate and enrich extracted data:
+
+- ✅ Tools can modify extracted data with `extractedUpdate`
+- ✅ Data validation and enrichment patterns
+- ✅ Flag-based conditional execution
+- ✅ Error handling and data correction
+- ✅ Multi-step data refinement
+
+**Key concepts:** Data validation, enrichment, extractedUpdate, flags
+
+```typescript
+const validateEmail = defineTool(
+  "validate_email",
+  async ({ extracted }) => {
+    const isValid = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(extracted.email);
+    return {
+      data: isValid,
+      extractedUpdate: {
+        emailValid: isValid, // Enrich extracted data
+      },
+    };
+  }
+);
+```
+
+---
+
+## 🤖 Provider Examples
+
+### 🌐 [OpenAI Agent](../examples/openai-agent.ts)
+
+**Perfect for:** Using GPT models
+
+GPT-5 integration with backup models:
+
+- ✅ OpenAI provider configuration
+- ✅ Backup model fallback
+- ✅ Retry configuration
+- ✅ Weather checking example
+
+**Key concepts:** OpenAI integration, model fallback
+
+### 🌐 Multiple Providers
+
+See how different AI providers work:
+
+- **[OpenAI Agent](../examples/openai-agent.ts)** - GPT-5 integration
+- **[Healthcare Agent](../examples/healthcare-agent.ts)** - Claude 3.5 Sonnet (Anthropic)
+- **[Travel Agent](../examples/travel-agent.ts)** - OpenRouter with backup models
+- All examples include backup model configuration and retry settings
+
+---
+
+## 📚 Additional Examples
+
+### 📊 [Company Q&A Agent](../examples/company-qna-agent.ts)
+
+**Perfect for:** Stateless question-answering systems
+
+Simple Q&A agent with knowledge base:
+
+- ✅ Stateless routes (no data extraction)
+- ✅ Knowledge base integration
+- ✅ Simple request-response pattern
+- ✅ Perfect for FAQ bots
+
+**Key concepts:** Stateless routing, Q&A patterns
+
+---
+
+## 🎯 How to Use These Examples
+
+### Running Examples
+
+```bash
+# Install dependencies
+bun install
+
+# Set up environment variables
+echo "GEMINI_API_KEY=your_key" > .env
+
+# Run an example
+bun examples/travel-agent.ts
+```
+
+### Learning Path
+
+1. **Start here:** [Declarative Agent](../examples/declarative-agent.ts) - Learn the basics
+2. **Simple flow:** [Travel Agent](../examples/travel-agent.ts) - Session state & extraction
+3. **Complex flow:** [Business Onboarding](../examples/business-onboarding.ts) - Branching & lifecycle
+4. **Add persistence:** [Prisma Persistence](../examples/prisma-persistence.ts) - Database integration
+5. **Add security:** [Domain Scoping](../examples/domain-scoping.ts) - Tool isolation
+
+### Quick Reference
+
+| Example | Best For | Key Features |
+|---------|----------|--------------|
+| Declarative Agent | Learning basics | Full API coverage |
+| Travel Agent | Session state | Multi-turn conversations |
+| Business Onboarding | Complex flows | Branching, lifecycle hooks |
+| Healthcare Agent | Security | Data validation, compliance |
+| Streaming Agent | Real-time UX | Streaming responses |
+| Domain Scoping | Security | Tool isolation |
+| Prisma Persistence | Production | Database integration |
+
+---
+
+## 💡 Tips
+
+**For Production:**
+- Use [Prisma Persistence](../examples/prisma-persistence.ts) for relational data
+- Use [Redis Persistence](../examples/redis-persistence.ts) for high-throughput
+- Implement [Domain Scoping](../examples/domain-scoping.ts) for security
+- Add [Rules & Prohibitions](../examples/rules-prohibitions.ts) for brand consistency
+
+**For Development:**
+- Start with [Declarative Agent](../examples/declarative-agent.ts)
+- Use [Streaming Agent](../examples/streaming-agent.ts) for better UX
+- Check [Custom Database Integration](../examples/custom-database-persistence.ts) for existing schemas
+
+---
+
+**Need help?** Check the [full documentation](./README.md) or [open an issue](https://github.com/gusnips/falai/issues).

package/docs/README.md

@@ -2,6 +2,8 @@
 
 Welcome to the `@falai/agent` documentation!
 
+📋 **[Complete Documentation Index →](DOCS.md)** - Full searchable index of all docs
+
 ## 📖 Documentation Structure
 
 ### Getting Started

package/examples/business-onboarding.ts

@@ -612,10 +612,12 @@ async function createBusinessOnboardingAgent(
     .transitionTo({
       id: "ask_improve",
       chatState: "Is there anything we could improve?",
+      condition: "User wants to provide feedback",
     })
     .transitionTo({
       id: "thank_you",
       chatState: "Thank you for your feedback! It helps us improve. 🙏",
+      condition: "User provided feedback",
     })
     .transitionTo({ state: END_ROUTE });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@falai/agent",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "description": "Standalone, strongly-typed AI Agent framework with route DSL and AI provider strategy",
   "type": "module",
   "main": "./dist/cjs/index.js",