morpheus-cli 0.3.4 → 0.3.6

package/dist/http/__tests__/status_with_server_api.test.js

@@ -1,60 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import request from 'supertest';
-import express from 'express';
-import bodyParser from 'body-parser';
-import { createApiRouter } from '../api.js';
-import { ConfigManager } from '../../config/manager.js';
-import fs from 'fs-extra';
-// Mock dependencies
-vi.mock('../../config/manager.js');
-vi.mock('fs-extra');
-describe('Status API with Server Instance', () => {
-    let app;
-    let mockConfigManager;
-    let mockServerInstance;
-    beforeEach(() => {
-        // Reset mocks
-        vi.clearAllMocks();
-        // Mock ConfigManager instance
-        mockConfigManager = {
-            get: vi.fn(),
-        };
-        ConfigManager.getInstance.mockReturnValue(mockConfigManager);
-        // Mock server instance with getPort method
-        mockServerInstance = {
-            getPort: vi.fn().mockReturnValue(4567),
-        };
-        // Setup App
-        app = express();
-        app.use(bodyParser.json());
-        // Create router with server instance
-        app.use('/api', createApiRouter(mockServerInstance));
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    describe('GET /api/status', () => {
-        it('should return status information with server instance port', async () => {
-            const mockConfig = {
-                agent: { name: 'TestAgent' },
-                llm: { provider: 'openai', model: 'gpt-4' },
-                ui: { port: 3333 } // This should be overridden by server instance
-            };
-            mockConfigManager.get.mockReturnValue(mockConfig);
-            // Mock fs.readJson to return a version
-            fs.readJson.mockResolvedValue({ version: '1.0.0' });
-            const res = await request(app).get('/api/status');
-            expect(res.status).toBe(200);
-            expect(res.body).toHaveProperty('status');
-            expect(res.body).toHaveProperty('uptimeSeconds');
-            expect(res.body).toHaveProperty('pid');
-            expect(res.body).toHaveProperty('projectVersion');
-            expect(res.body).toHaveProperty('nodeVersion');
-            expect(res.body).toHaveProperty('agentName');
-            expect(res.body).toHaveProperty('llmProvider');
-            expect(res.body).toHaveProperty('llmModel');
-            expect(res.body).toHaveProperty('serverPort');
-            expect(res.body.serverPort).toBe(4567); // Should come from server instance
-        });
-    });
-});

package/dist/runtime/__tests__/agent.test.js

@@ -1,95 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Agent } from '../agent.js';
-import { ProviderFactory } from '../providers/factory.js';
-import { ToolsFactory } from '../tools/factory.js';
-import { DEFAULT_CONFIG } from '../../types/config.js';
-import { AIMessage } from '@langchain/core/messages';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import { homedir } from 'os';
-vi.mock('../providers/factory.js');
-vi.mock('../tools/factory.js');
-describe('Agent', () => {
-    let agent;
-    const mockProvider = {
-        invoke: vi.fn(),
-    };
-    beforeEach(async () => {
-        vi.resetAllMocks();
-        // Clean up any existing test database
-        const defaultDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
-        if (fs.existsSync(defaultDbPath)) {
-            try {
-                const Database = (await import("better-sqlite3")).default;
-                const db = new Database(defaultDbPath);
-                db.exec("DELETE FROM messages");
-                db.close();
-            }
-            catch (err) {
-                // Ignore errors if database doesn't exist or is corrupted
-            }
-        }
-        mockProvider.invoke.mockResolvedValue({ messages: [new AIMessage('Hello world')] });
-        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
-        vi.mocked(ToolsFactory.create).mockResolvedValue([]);
-        agent = new Agent(DEFAULT_CONFIG);
-    });
-    afterEach(async () => {
-        // Clean up after each test
-        if (agent) {
-            try {
-                await agent.clearMemory();
-            }
-            catch (err) {
-                // Ignore cleanup errors
-            }
-        }
-    });
-    it('should initialize successfully', async () => {
-        await agent.initialize();
-        expect(ToolsFactory.create).toHaveBeenCalled();
-        expect(ProviderFactory.create).toHaveBeenCalledWith(DEFAULT_CONFIG.llm, []);
-    });
-    it('should chat successfully', async () => {
-        await agent.initialize();
-        const response = await agent.chat('Hi');
-        expect(response).toBe('Hello world');
-        expect(mockProvider.invoke).toHaveBeenCalled();
-    });
-    it('should throw if not initialized', async () => {
-        await expect(agent.chat('Hi')).rejects.toThrow('initialize() first');
-    });
-    it('should maintain history', async () => {
-        await agent.initialize();
-        // Clear any residual history from previous tests
-        await agent.clearMemory();
-        // First turn
-        await agent.chat('Hi');
-        const history1 = await agent.getHistory();
-        expect(history1).toHaveLength(2);
-        expect(history1[0].content).toBe('Hi'); // User
-        expect(history1[1].content).toBe('Hello world'); // AI
-        // Second turn
-        // Update mock return value for next call
-        mockProvider.invoke.mockResolvedValue({ messages: [new AIMessage('I am fine')] });
-        await agent.chat('How are you?');
-        const history2 = await agent.getHistory();
-        expect(history2).toHaveLength(4);
-        expect(history2[2].content).toBe('How are you?');
-        expect(history2[3].content).toBe('I am fine');
-    });
-    describe('Configuration Validation', () => {
-        it('should throw if llm provider is missing', async () => {
-            const invalidConfig = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
-            delete invalidConfig.llm.provider; // Invalid
-            const badAgent = new Agent(invalidConfig);
-            await expect(badAgent.initialize()).rejects.toThrow('LLM provider not specified');
-        });
-        it('should propagate ProviderError during initialization', async () => {
-            const mockError = new Error("Mock Factory Error");
-            vi.mocked(ProviderFactory.create).mockImplementation(() => { throw mockError; });
-            // ProviderError constructs message as: "Provider {provider} failed: {originalError.message}"
-            await expect(agent.initialize()).rejects.toThrow('Provider openai failed: Mock Factory Error');
-        });
-    });
-});

package/dist/runtime/__tests__/agent_memory_limit.test.js

@@ -1,61 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { Agent } from '../agent.js';
-import { ProviderFactory } from '../providers/factory.js';
-import { DEFAULT_CONFIG } from '../../types/config.js';
-import { AIMessage } from '@langchain/core/messages';
-import * as fs from 'fs-extra';
-import * as path from 'path';
-import { homedir } from 'os';
-vi.mock('../providers/factory.js');
-describe('Agent Memory Limit', () => {
-    let agent;
-    const mockProvider = {
-        invoke: vi.fn(),
-    };
-    const dbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
-    beforeEach(async () => {
-        vi.resetAllMocks();
-        // Clean up DB
-        if (fs.existsSync(dbPath)) {
-            try {
-                const Database = (await import("better-sqlite3")).default;
-                const db = new Database(dbPath);
-                db.exec("DELETE FROM messages");
-                db.close();
-            }
-            catch (err) { }
-        }
-        mockProvider.invoke.mockResolvedValue({
-            messages: [new AIMessage('Response')]
-        });
-        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
-    });
-    afterEach(async () => {
-        if (agent) {
-            try {
-                await agent.clearMemory();
-            }
-            catch (err) { }
-        }
-    });
-    it('should respect configured memory limit', async () => {
-        const limitedConfig = JSON.parse(JSON.stringify(DEFAULT_CONFIG));
-        limitedConfig.memory.limit = 2; // Only last 2 messages (1 exchange)
-        agent = new Agent(limitedConfig);
-        await agent.initialize();
-        // Turn 1
-        await agent.chat('Msg 1');
-        // Turn 2
-        await agent.chat('Msg 2');
-        // Turn 3
-        await agent.chat('Msg 3');
-        // DB should have 6 messages (3 User + 3 AI)
-        // getHistory() should return only 2 (User Msg 3 + AI Response)
-        // Wait, SQLiteChatMessageHistory limit might be total messages? Or pairs?
-        // LangChain's limit usually means "last N messages".
-        const history = await agent.getHistory();
-        // Assuming limit=2 means 2 messages.
-        expect(history.length).toBeLessThanOrEqual(2);
-        expect(history[history.length - 1].content).toBe('Response');
-    });
-});

package/dist/runtime/__tests__/agent_persistence.test.js

@@ -1,154 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
-import { Agent } from "../agent.js";
-import { ProviderFactory } from "../providers/factory.js";
-import { DEFAULT_CONFIG } from "../../types/config.js";
-import { AIMessage } from "@langchain/core/messages";
-import * as fs from "fs-extra";
-import * as path from "path";
-import { tmpdir } from "os";
-import { ToolsFactory } from "../tools/factory.js";
-vi.mock("../providers/factory.js");
-vi.mock("../tools/factory.js");
-describe("Agent Persistence Integration", () => {
-    let agent;
-    let testDbPath;
-    let tempDir;
-    const mockProvider = {
-        invoke: vi.fn(),
-    };
-    beforeEach(async () => {
-        vi.resetAllMocks();
-        // Create a unique temporary test database path for each test to avoid interference
-        tempDir = path.join(tmpdir(), "morpheus-test-agent", Date.now().toString() + Math.random().toString(36).substring(7));
-        testDbPath = path.join(tempDir, "short-memory.db");
-        mockProvider.invoke.mockImplementation(async ({ messages }) => {
-            return {
-                messages: [...messages, new AIMessage("Test response")]
-            };
-        });
-        vi.mocked(ProviderFactory.create).mockResolvedValue(mockProvider);
-        vi.mocked(ToolsFactory.create).mockResolvedValue([]);
-        agent = new Agent(DEFAULT_CONFIG, { databasePath: testDbPath });
-    });
-    afterEach(async () => {
-        // Clean up temporary test directory
-        if (fs.existsSync(tempDir)) {
-            try {
-                fs.removeSync(tempDir);
-            }
-            catch (err) {
-                // Ignore removal errors if file is locked
-            }
-        }
-    });
-    describe("Database File Creation", () => {
-        it("should create database file on initialization", async () => {
-            await agent.initialize();
-            expect(fs.existsSync(testDbPath)).toBe(true);
-        });
-    });
-    describe("Message Persistence", () => {
-        it("should persist messages to database", async () => {
-            await agent.initialize();
-            // Send a message
-            await agent.chat("Hello, Agent!");
-            // Verify history contains the message
-            const history = await agent.getHistory();
-            expect(history).toHaveLength(2); // User message + AI response
-            expect(history[0].content).toBe("Hello, Agent!");
-            expect(history[1].content).toBe("Test response");
-        });
-        it("should restore conversation history on restart", async () => {
-            // First session: send a message
-            await agent.initialize();
-            await agent.chat("Remember this message");
-            const firstHistory = await agent.getHistory();
-            expect(firstHistory).toHaveLength(2);
-            // Simulate restart: create new agent instance with SAME database path
-            const agent2 = new Agent(DEFAULT_CONFIG, { databasePath: testDbPath });
-            await agent2.initialize();
-            // Verify history was restored
-            const restoredHistory = await agent2.getHistory();
-            expect(restoredHistory.length).toBeGreaterThanOrEqual(2);
-            // Check that the old messages are present
-            const contents = restoredHistory.map(m => m.content);
-            expect(contents).toContain("Remember this message");
-            expect(contents).toContain("Test response");
-        });
-        it("should accumulate messages across multiple conversations", async () => {
-            await agent.initialize();
-            // First conversation
-            await agent.chat("First message");
-            // Second conversation
-            mockProvider.invoke.mockImplementation(async ({ messages }) => {
-                return {
-                    messages: [...messages, new AIMessage("Second response")]
-                };
-            });
-            await agent.chat("Second message");
-            // Verify all messages are persisted
-            const history = await agent.getHistory();
-            expect(history).toHaveLength(4);
-            expect(history[0].content).toBe("First message");
-            expect(history[1].content).toBe("Test response");
-            expect(history[2].content).toBe("Second message");
-            expect(history[3].content).toBe("Second response");
-        });
-    });
-    describe("Memory Clearing", () => {
-        it("should clear all persisted messages", async () => {
-            await agent.initialize();
-            // Add some messages
-            await agent.chat("Message 1");
-            await agent.chat("Message 2");
-            // Verify messages exist
-            let history = await agent.getHistory();
-            expect(history.length).toBeGreaterThan(0);
-            // Clear memory
-            await agent.clearMemory();
-            // Verify messages are cleared
-            history = await agent.getHistory();
-            expect(history).toEqual([]);
-        });
-        it("should start fresh after clearing memory", async () => {
-            await agent.initialize();
-            // Add and clear messages
-            await agent.chat("Old message");
-            await agent.clearMemory();
-            // Add new message
-            mockProvider.invoke.mockImplementation(async ({ messages }) => {
-                return {
-                    messages: [...messages, new AIMessage("New response")]
-                };
-            });
-            await agent.chat("New message");
-            // Verify only new messages exist
-            const history = await agent.getHistory();
-            expect(history).toHaveLength(2);
-            expect(history[0].content).toBe("New message");
-            expect(history[1].content).toBe("New response");
-        });
-    });
-    describe("Context Preservation", () => {
-        it("should include history in conversation context", async () => {
-            await agent.initialize();
-            // First message
-            await agent.chat("My name is Alice");
-            // Second message (should have context)
-            mockProvider.invoke.mockImplementation(async ({ messages }) => {
-                return {
-                    messages: [...messages, new AIMessage("Hello Alice!")]
-                };
-            });
-            await agent.chat("What is my name?");
-            // Verify the provider was called with full history
-            const lastCall = mockProvider.invoke.mock.calls[1];
-            const messagesPassedToLLM = lastCall[0].messages;
-            // Should include: system message, previous user message, previous AI response, new user message
-            expect(messagesPassedToLLM.length).toBeGreaterThanOrEqual(4);
-            // Check that context includes the original message
-            const contents = messagesPassedToLLM.map((m) => m.content);
-            expect(contents).toContain("My name is Alice");
-        });
-    });
-});

package/dist/runtime/__tests__/manual_santi_verify.js

@@ -1,55 +0,0 @@
-import { Santi } from "../santi/santi.js";
-import { ConfigManager } from "../../config/manager.js";
-import * as path from "path";
-import { homedir } from "os";
-async function main() {
-    console.log("Starting Santi Manual Verification...");
-    // 1. Check DB isolation
-    const santiDbPath = path.join(homedir(), ".morpheus", "memory", "santi-memory.db");
-    const shortDbPath = path.join(homedir(), ".morpheus", "memory", "short-memory.db");
-    console.log(`Checking DB paths: \n- ${santiDbPath}\n- ${shortDbPath}`);
-    // 2. Initialize Santi
-    const santi = new Santi();
-    console.log("Santi initialized.");
-    // 3. Test Recovery (should be empty or have data if prev run)
-    let memories = await santi.recover("test");
-    console.log(`Initial recovery "test": ${memories.length} items`);
-    // 4. Manually add memory via internal store (reflection hack for test)
-    console.log("Injecting test memory...");
-    // @ts-ignore
-    santi.store.addMemory({
-        category: 'preference',
-        importance: 'high',
-        summary: 'The user loves manual testing scripts.',
-        hash: 'manual-test-hash',
-        source: 'manual_test'
-    });
-    // 5. Test Recovery again
-    memories = await santi.recover("loves manual testing");
-    console.log(`Recovery after injection "loves manual testing": ${memories.length} items`);
-    if (memories.length > 0 && memories[0].summary.includes("loves manual testing")) {
-        console.log("✅ Recovery SUCCESS");
-    }
-    else {
-        console.error("❌ Recovery FAILED");
-    }
-    // 6. Test Evaluate (Mocking messages)
-    // This requires LLM config to be present. 
-    // We skip this in manual test if no config, but logging will show warning.
-    if (ConfigManager.getInstance().get().llm) {
-        console.log("Testing Evaluate (dry run with LLM)...");
-        // This will assume valid LLM config
-        /*
-        await santi.evaluate([
-            new HumanMessage("My name is Morpheus Tester."),
-            new AIMessage("Nice to meet you.")
-        ]);
-        */
-        console.log("Evaluate test skipped to avoid api cost, but code is in place.");
-    }
-    else {
-        console.log("Skipping Evaluate test (no LLM config).");
-    }
-    console.log("Verification Complete.");
-}
-main().catch(console.error);

package/dist/runtime/agent.js

@@ -1,172 +0,0 @@
-import { HumanMessage, SystemMessage } from "@langchain/core/messages";
-import { ProviderFactory } from "./providers/factory.js";
-import { ToolsFactory } from "./tools/factory.js";
-import { ConfigManager } from "../config/manager.js";
-import { ProviderError } from "./errors.js";
-import { DisplayManager } from "./display.js";
-import { SQLiteChatMessageHistory } from "./memory/sqlite.js";
-export class Agent {
-    provider;
-    config;
-    history;
-    display = DisplayManager.getInstance();
-    databasePath;
-    constructor(config, overrides) {
-        this.config = config || ConfigManager.getInstance().get();
-        this.databasePath = overrides?.databasePath;
-    }
-    async initialize() {
-        if (!this.config.llm) {
-            throw new Error("LLM configuration missing in config object.");
-        }
-        // Basic validation before provider creation
-        if (!this.config.llm.provider) {
-            throw new Error("LLM provider not specified in configuration.");
-        }
-        // Note: API Key validation is delegated to ProviderFactory or the Provider itself 
-        // to allow for Environment Variable fallback supported by LangChain.
-        try {
-            const tools = await ToolsFactory.create();
-            this.provider = await ProviderFactory.create(this.config.llm, tools);
-            if (!this.provider) {
-                throw new Error("Provider factory returned undefined");
-            }
-            // Initialize persistent memory with SQLite
-            this.history = new SQLiteChatMessageHistory({
-                sessionId: "default",
-                databasePath: this.databasePath,
-                limit: this.config.memory?.limit || 100, // Fallback purely defensive if config type allows optional
-            });
-        }
-        catch (err) {
-            if (err instanceof ProviderError)
-                throw err; // Re-throw known errors
-            // Wrap unknown errors
-            throw new ProviderError(this.config.llm.provider || 'unknown', err, "Agent initialization failed");
-        }
-    }
-    async chat(message, extraUsage) {
-        if (!this.provider) {
-            throw new Error("Agent not initialized. Call initialize() first.");
-        }
-        if (!this.history) {
-            throw new Error("Message history not initialized. Call initialize() first.");
-        }
-        try {
-            this.display.log('Processing message...', { source: 'Agent' });
-            const userMessage = new HumanMessage(message);
-            // Inject provider/model metadata for persistence
-            userMessage.provider_metadata = {
-                provider: this.config.llm.provider,
-                model: this.config.llm.model
-            };
-            // Attach extra usage (e.g. from Audio) to the user message to be persisted
-            if (extraUsage) {
-                userMessage.usage_metadata = extraUsage;
-            }
-            const systemMessage = new SystemMessage(`You are ${this.config.agent.name}, ${this.config.agent.personality},a local AI operator responsible for orchestrating tools, MCPs, and language models to solve the user’s request accurately and reliably.
-
-          Your primary responsibility is NOT to answer from memory when external tools are available.
-
-          You must follow these rules strictly:
-
-          1. Tool Evaluation First
-          Before generating a final answer, always evaluate whether any available tool or MCP is capable of providing a more accurate, up-to-date, or authoritative response.
-
-          If a tool can provide the answer, you MUST call the tool.
-
-          2. No Historical Assumptions for Dynamic Data
-          If the user asks something that:
-          - may change over time
-          - depends on system state
-          - depends on filesystem
-          - depends on external APIs
-          - was previously asked in the conversation
-
-          You MUST NOT reuse previous outputs as final truth.
-
-          Instead:
-          - Re-evaluate available tools
-          - Re-execute the relevant tool
-          - Provide a fresh result
-
-          Even if the user already asked the same question before, you must treat the request as requiring a new verification.
-
-          3. History Is Context, Not Source of Truth
-          Conversation history may help with context, but it must not replace real-time verification via tools when tools are available.
-
-          Never assume:
-          - System state
-          - File contents
-          - Database values
-          - API responses
-          based only on previous messages.
-
-          4. Tool Priority Over Language Guessing
-          If a tool can compute, fetch, inspect, or verify something, prefer tool usage over generating a speculative answer.
-
-          Never hallucinate values that could be retrieved through a tool.
-
-          5. Freshness Principle
-          Repeated user queries require fresh validation.
-          Do not respond with:
-          "As I said before..."
-          Instead, perform a new tool check if applicable.
-
-          6. Final Answer Policy
-          Only provide a direct natural language answer if:
-          - No tool is relevant
-          - Tools are unavailable
-          - The question is conceptual or explanatory
-
-          Otherwise, use tools first.
-
-          You are an operator, not a guesser.
-          Accuracy is more important than speed.
-      `);
-            // Load existing history from database
-            const previousMessages = await this.history.getMessages();
-            const messages = [
-                systemMessage,
-                ...previousMessages,
-                userMessage
-            ];
-            const response = await this.provider.invoke({ messages });
-            // Identify new messages generated during the interaction
-            // The `messages` array passed to invoke had length `messages.length`
-            // The `response.messages` contains the full state.
-            // New messages start after the inputs.
-            const startNewMessagesIndex = messages.length;
-            const newGeneratedMessages = response.messages.slice(startNewMessagesIndex);
-            // Persist User Message first
-            await this.history.addMessage(userMessage);
-            // Persist all new intermediate tool calls and responses
-            for (const msg of newGeneratedMessages) {
-                // Inject provider/model metadata search interactors
-                msg.provider_metadata = {
-                    provider: this.config.llm.provider,
-                    model: this.config.llm.model
-                };
-                await this.history.addMessage(msg);
-            }
-            this.display.log('Response generated.', { source: 'Agent' });
-            const lastMessage = response.messages[response.messages.length - 1];
-            return (typeof lastMessage.content === 'string') ? lastMessage.content : JSON.stringify(lastMessage.content);
-        }
-        catch (err) {
-            throw new ProviderError(this.config.llm.provider, err, "Chat request failed");
-        }
-    }
-    async getHistory() {
-        if (!this.history) {
-            throw new Error("Message history not initialized. Call initialize() first.");
-        }
-        return await this.history.getMessages();
-    }
-    async clearMemory() {
-        if (!this.history) {
-            throw new Error("Message history not initialized. Call initialize() first.");
-        }
-        await this.history.clear();
-    }
-}

package/dist/runtime/audio-agent.js

@@ -1,55 +0,0 @@
-import { GoogleGenAI } from '@google/genai';
-export class AudioAgent {
-    async transcribe(filePath, mimeType, apiKey) {
-        try {
-            const ai = new GoogleGenAI({ apiKey });
-            // Upload the file
-            const uploadResult = await ai.files.upload({
-                file: filePath,
-                config: { mimeType }
-            });
-            // Generate content (transcription)
-            // using gemini-1.5-flash as it is fast and supports audio
-            const response = await ai.models.generateContent({
-                model: 'gemini-2.5-flash-lite',
-                contents: [
-                    {
-                        role: 'user',
-                        parts: [
-                            {
-                                fileData: {
-                                    fileUri: uploadResult.uri,
-                                    mimeType: uploadResult.mimeType
-                                }
-                            },
-                            { text: "Transcribe this audio message accurately. Return only the transcribed text without any additional commentary." }
-                        ]
-                    }
-                ]
-            });
-            // The new SDK returns text directly on the response object
-            const text = response.text;
-            if (!text) {
-                throw new Error('No transcription generated');
-            }
-            // Extract usage metadata
-            const usage = response.usageMetadata;
-            const usageMetadata = {
-                input_tokens: usage?.promptTokenCount ?? 0,
-                output_tokens: usage?.candidatesTokenCount ?? 0,
-                total_tokens: usage?.totalTokenCount ?? 0,
-                input_token_details: {
-                    cache_read: usage?.cachedContentTokenCount ?? 0
-                }
-            };
-            return { text, usage: usageMetadata };
-        }
-        catch (error) {
-            // Wrap error for clarity
-            if (error instanceof Error) {
-                throw new Error(`Audio transcription failed: ${error.message}`);
-            }
-            throw error;
-        }
-    }
-}

package/dist/runtime/santi/contracts.js

@@ -1 +0,0 @@
-export {};