rail port solid shit inDS

[fukurou]

vb.net:

Public Class QuestionChecker
    Private Shared ReadOnly QUESTION_WORDS As HashSet(Of String) = New HashSet(Of String) From {
    "what", "who", "where", "when", "why", "how",
    "is", "are", "was", "were", "do", "does", "did",
    "can", "could", "would", "will", "shall", "should",
    "have", "has", "am", "may", "might"
}

    Public Shared Function IsQuestion(ByVal input As String) As Boolean
        If String.IsNullOrWhiteSpace(input) Then
            Return False
        End If

        Dim trimmed As String = input.Trim().ToLower()

        ' Check for question mark
        If trimmed.EndsWith("?") Then
            Return True
        End If

        ' Extract the first word
        Dim firstSpace As Integer = trimmed.IndexOf(" "c)
        Dim firstWord As String = If(firstSpace = -1, trimmed, trimmed.Substring(0, firstSpace))

        ' Check for contractions like "who's"
        If firstWord.Contains("'") Then
            firstWord = firstWord.Substring(0, firstWord.IndexOf("'"c))
        End If

        ' Check if first word is a question word
        Return QUESTION_WORDS.Contains(firstWord)
    End Function
End Class

 

[fukurou]

vb.net:

Public Class PhraseInflector
    ' Dictionary for pronoun and verb inflection
    Private Shared ReadOnly inflectionMap As New Dictionary(Of String, String) From {
        {"i", "you"},
        {"me", "you"},
        {"my", "your"},
        {"mine", "yours"},
        {"you", "i"}, ' Default inflection
        {"your", "my"},
        {"yours", "mine"},
        {"am", "are"},
        {"are", "am"},
        {"was", "were"},
        {"were", "was"},
        {"i'd", "you would"},
        {"i've", "you have"},
        {"you've", "I have"},
        {"you'll", "I will"}
    }

    ' Function to inflect a phrase
    Public Shared Function InflectPhrase(ByVal phrase As String) As String
        Dim words As String() = phrase.Split(" "c)
        Dim result As New Text.StringBuilder()

        For i As Integer = 0 To words.Length - 1
            Dim word As String = words(i)
            Dim lowerWord As String = word.ToLower()
            Dim inflectedWord As String = word ' Default to the original word

            ' Check if the word needs to be inflected
            If inflectionMap.ContainsKey(lowerWord) Then
                inflectedWord = inflectionMap(lowerWord)

                ' Special case for "you"
                If lowerWord = "you" Then
                    ' Inflect to "me" if it's at the end of the sentence or after a verb
                    If i = words.Length - 1 OrElse (i > 0 AndAlso IsVerb(words(i - 1).ToLower())) Then
                        inflectedWord = "me"
                    Else
                        inflectedWord = "I"
                    End If
                End If
            End If

            ' Preserve capitalization
            If Char.IsUpper(word(0)) Then
                inflectedWord = inflectedWord.Substring(0, 1).ToUpper() & inflectedWord.Substring(1)
            End If

            result.Append(inflectedWord).Append(" ")
        Next

        Return result.ToString().Trim()
    End Function

    ' Helper function to check if a word is a verb
    Private Shared Function IsVerb(ByVal word As String) As Boolean
        Return word = "am" OrElse word = "are" OrElse word = "was" OrElse word = "were" OrElse
               word = "have" OrElse word = "has" OrElse word = "had" OrElse
               word = "do" OrElse word = "does" OrElse word = "did"
    End Function
End Class

 

[fukurou]

Public Class RailBot
    Private ReadOnly ec As EventChatV2
    Private context As String = "stand by"
    Private elizaWrapper As ElizaDBWrapper = Nothing ' Starts as Nothing (no DB)

    ' Constructor with limit parameter
    Public Sub New(ByVal limit As Integer)
        ec = New EventChatV2(limit)
    End Sub

    ' Default constructor
    Public Sub New()
        Me.New(5)
    End Sub

    ''' <summary>
    ''' Enables database features. Must be called before any save/load operations.
    ''' If never called, RailBot works in memory-only mode.
    ''' </summary>
    Public Sub EnableDBWrapper()
        If elizaWrapper Is Nothing Then
            elizaWrapper = New ElizaDBWrapper()
        End If
    End Sub

    ''' <summary>
    ''' Disables database features.
    ''' </summary>
    Public Sub DisableDBWrapper()
        elizaWrapper = Nothing
    End Sub

    ''' <summary>
    ''' Sets the context.
    ''' </summary>
    ''' <param name="newContext">The new context string.</param>
    Public Sub SetContext(ByVal newContext As String)
        If String.IsNullOrEmpty(newContext) Then
            Return
        End If
        context = newContext
    End Sub

    ''' <summary>
    ''' Private helper method for monolog response.
    ''' </summary>
    Private Function RespondMonolog(ByVal ear As String) As String
        If String.IsNullOrEmpty(ear) Then
            Return ""
        End If

        Dim temp As String = ec.Response(ear)
        If Not String.IsNullOrEmpty(temp) Then
            context = temp
        End If
        Return temp
    End Function

    ''' <summary>
    ''' Learns a new response for the current context.
    ''' </summary>
    Public Sub Learn(ByVal ear As String)
        If String.IsNullOrEmpty(ear) OrElse ear.Equals(context) Then
            Return
        End If
        ec.AddKeyValue(context, ear)
        context = ear
    End Sub

    ''' <summary>
    ''' Returns a monolog based on the current context.
    ''' </summary>
    Public Function Monolog() As String
        Return RespondMonolog(context)
    End Function

    ''' <summary>
    ''' Responds to a dialog input.
    ''' </summary>
    Public Function RespondDialog(ByVal ear As String) As String
        Return ec.Response(ear)
    End Function

    ''' <summary>
    ''' Responds to the latest input.
    ''' </summary>
    Public Function RespondLatest(ByVal ear As String) As String
        Return ec.ResponseLatest(ear)
    End Function

    ''' <summary>
    ''' Adds a new key-value pair to the memory.
    ''' </summary>
    Public Sub LearnKeyValue(ByVal newContext As String, ByVal reply As String)
        ec.AddKeyValue(newContext, reply)
    End Sub

    ''' <summary>
    ''' Feeds a list of key-value pairs into the memory.
    ''' </summary>
    Public Sub FeedKeyValuePairs(ByVal kvList As List(Of AXKeyValuePair))
        If kvList.Count = 0 Then
            Return
        End If
        For Each kv As AXKeyValuePair In kvList
            LearnKeyValue(kv.GetKey(), kv.GetValue())
        Next
    End Sub

    ''' <summary>
    ''' Saves learned data using the provided Kokoro instance.
    ''' </summary>
    Public Sub SaveLearnedData(ByVal kokoro As Kokoro)
        If elizaWrapper Is Nothing Then
            Return
        End If
        elizaWrapper.SleepNSave(ec, kokoro)
    End Sub

    ''' <summary>
    ''' Private helper method for loadable monolog mechanics.
    ''' </summary>
    Private Function LoadableMonologMechanics(ByVal ear As String, ByVal kokoro As Kokoro) As String
        If String.IsNullOrEmpty(ear) Then
            Return ""
        End If

        Dim temp As String = elizaWrapper.Respond(ear, ec, kokoro)
        If Not String.IsNullOrEmpty(temp) Then
            context = temp
        End If
        Return temp
    End Function

    ''' <summary>
    ''' Returns a loadable monolog based on the current context.
    ''' </summary>
    Public Function LoadableMonolog(ByVal kokoro As Kokoro) As String
        If elizaWrapper Is Nothing Then
            Return Monolog()
        End If
        Return LoadableMonologMechanics(context, kokoro)
    End Function

    ''' <summary>
    ''' Returns a loadable dialog response.
    ''' </summary>
    Public Function LoadableDialog(ByVal ear As String, ByVal kokoro As Kokoro) As String
        If elizaWrapper Is Nothing Then
            Return RespondDialog(ear)
        End If
        Return elizaWrapper.Respond(ear, ec, kokoro)
    End Function
End Class

 

[fukurou]

public class QuestionChecker
{
    private static readonly HashSet<string> QUESTION_WORDS = new HashSet<string>
    {
        "what", "who", "where", "when", "why", "how",
        "is", "are", "was", "were", "do", "does", "did",
        "can", "could", "would", "will", "shall", "should",
        "have", "has", "am", "may", "might"
    };

    public static bool IsQuestion(string input)
    {
        if (string.IsNullOrWhiteSpace(input))
        {
            return false;
        }

        string trimmed = input.Trim().ToLower();

        // Check for question mark
        if (trimmed.EndsWith("?"))
        {
            return true;
        }

        // Extract the first word
        int firstSpace = trimmed.IndexOf(' ');
        string firstWord = firstSpace == -1 ? trimmed : trimmed.Substring(0, firstSpace);

        // Check for contractions like "who's"
        if (firstWord.Contains("'"))
        {
            firstWord = firstWord.Substring(0, firstWord.IndexOf('\''));
        }

        // Check if first word is a question word
        return QUESTION_WORDS.Contains(firstWord);
    }
}

 

[fukurou]

public class PhraseInflector
{
    // Dictionary for pronoun and verb inflection
    private static readonly Dictionary<string, string> inflectionMap = new Dictionary<string, string>
    {
        {"i", "you"},
        {"me", "you"},
        {"my", "your"},
        {"mine", "yours"},
        {"you", "i"}, // Default inflection
        {"your", "my"},
        {"yours", "mine"},
        {"am", "are"},
        {"are", "am"},
        {"was", "were"},
        {"were", "was"},
        {"i'd", "you would"},
        {"i've", "you have"},
        {"you've", "I have"},
        {"you'll", "I will"}
    };

    // Function to inflect a phrase
    public static string InflectPhrase(string phrase)
    {
        string[] words = phrase.Split(' ');
        var result = new System.Text.StringBuilder();

        for (int i = 0; i < words.Length; i++)
        {
            string word = words[i];
            string lowerWord = word.ToLower();
            string inflectedWord = word; // Default to the original word

            // Check if the word needs to be inflected
            if (inflectionMap.ContainsKey(lowerWord))
            {
                inflectedWord = inflectionMap[lowerWord];

                // Special case for "you"
                if (lowerWord == "you")
                {
                    // Inflect to "me" if it's at the end of the sentence or after a verb
                    if (i == words.Length - 1 || (i > 0 && IsVerb(words[i - 1].ToLower())))
                    {
                        inflectedWord = "me";
                    }
                    else
                    {
                        inflectedWord = "I";
                    }
                }
            }

            // Preserve capitalization
            if (char.IsUpper(word[0]))
            {
                inflectedWord = char.ToUpper(inflectedWord[0]) + inflectedWord.Substring(1);
            }

            result.Append(inflectedWord).Append(" ");
        }

        return result.ToString().Trim();
    }

    // Helper function to check if a word is a verb
    private static bool IsVerb(string word)
    {
        return word == "am" || word == "are" || word == "was" || word == "were" ||
               word == "have" || word == "has" || word == "had" ||
               word == "do" || word == "does" || word == "did";
    }
}

 

[fukurou]

public class RailBot
{
    private readonly EventChatV2 ec;
    private string context = "stand by";
    private ElizaDBWrapper elizaWrapper = null; // Starts as null (no DB)

    // Constructor with limit parameter
    public RailBot(int limit)
    {
        ec = new EventChatV2(limit);
    }

    // Default constructor
    public RailBot() : this(5) { }

    /// <summary>
    /// Enables database features. Must be called before any save/load operations.
    /// If never called, RailBot works in memory-only mode.
    /// </summary>
    public void EnableDBWrapper()
    {
        if (elizaWrapper == null)
        {
            elizaWrapper = new ElizaDBWrapper();
        }
    }

    /// <summary>
    /// Disables database features.
    /// </summary>
    public void DisableDBWrapper()
    {
        elizaWrapper = null;
    }

    /// <summary>
    /// Sets the context.
    /// </summary>
    /// <param name="newContext">The new context string.</param>
    public void SetContext(string newContext)
    {
        if (string.IsNullOrEmpty(newContext))
        {
            return;
        }
        context = newContext;
    }

    /// <summary>
    /// Private helper method for monolog response.
    /// </summary>
    private string RespondMonolog(string ear)
    {
        if (string.IsNullOrEmpty(ear))
        {
            return "";
        }

        string temp = ec.Response(ear);
        if (!string.IsNullOrEmpty(temp))
        {
            context = temp;
        }
        return temp;
    }

    /// <summary>
    /// Learns a new response for the current context.
    /// </summary>
    public void Learn(string ear)
    {
        if (string.IsNullOrEmpty(ear) || ear.Equals(context))
        {
            return;
        }
        ec.AddKeyValue(context, ear);
        context = ear;
    }

    /// <summary>
    /// Returns a monolog based on the current context.
    /// </summary>
    public string Monolog()
    {
        return RespondMonolog(context);
    }

    /// <summary>
    /// Responds to a dialog input.
    /// </summary>
    public string RespondDialog(string ear)
    {
        return ec.Response(ear);
    }

    /// <summary>
    /// Responds to the latest input.
    /// </summary>
    public string RespondLatest(string ear)
    {
        return ec.ResponseLatest(ear);
    }

    /// <summary>
    /// Adds a new key-value pair to the memory.
    /// </summary>
    public void LearnKeyValue(string newContext, string reply)
    {
        ec.AddKeyValue(newContext, reply);
    }

    /// <summary>
    /// Feeds a list of key-value pairs into the memory.
    /// </summary>
    public void FeedKeyValuePairs(System.Collections.Generic.List<AXKeyValuePair> kvList)
    {
        if (kvList.Count == 0)
        {
            return;
        }
        foreach (AXKeyValuePair kv in kvList)
        {
            LearnKeyValue(kv.GetKey(), kv.GetValue());
        }
    }

    /// <summary>
    /// Saves learned data using the provided Kokoro instance.
    /// </summary>
    public void SaveLearnedData(Kokoro kokoro)
    {
        if (elizaWrapper == null)
        {
            return;
        }
        elizaWrapper.SleepNSave(ec, kokoro);
    }

    /// <summary>
    /// Private helper method for loadable monolog mechanics.
    /// </summary>
    private string LoadableMonologMechanics(string ear, Kokoro kokoro)
    {
        if (string.IsNullOrEmpty(ear))
        {
            return "";
        }

        string temp = elizaWrapper.Respond(ear, ec, kokoro);
        if (!string.IsNullOrEmpty(temp))
        {
            context = temp;
        }
        return temp;
    }

    /// <summary>
    /// Returns a loadable monolog based on the current context.
    /// </summary>
    public string LoadableMonolog(Kokoro kokoro)
    {
        if (elizaWrapper == null)
        {
            return Monolog();
        }
        return LoadableMonologMechanics(context, kokoro);
    }

    /// <summary>
    /// Returns a loadable dialog response.
    /// </summary>
    public string LoadableDialog(string ear, Kokoro kokoro)
    {
        if (elizaWrapper == null)
        {
            return RespondDialog(ear);
        }
        return elizaWrapper.Respond(ear, ec, kokoro);
    }
}

 

[fukurou]

public class RailBot
{
    private readonly EventChatV2 ec;
    private string context = "stand by";
    private ElizaDBWrapper? elizaWrapper = null; // Starts as null (no DB)

    // Constructor with limit parameter
    public RailBot(int limit)
    {
        ec = new EventChatV2(limit);
    }

    // Default constructor
    public RailBot() : this(5) { }

    /// <summary>
    /// Enables database features. Must be called before any save/load operations.
    /// If never called, RailBot works in memory-only mode.
    /// </summary>
    public void EnableDBWrapper()
    {
        if (elizaWrapper == null)
        {
            elizaWrapper = new ElizaDBWrapper();
        }
    }

    /// <summary>
    /// Disables database features.
    /// </summary>
    public void DisableDBWrapper()
    {
        elizaWrapper = null;
    }

    /// <summary>
    /// Sets the context.
    /// </summary>
    /// <param name="newContext">The new context string.</param>
    public void SetContext(string newContext)
    {
        if (string.IsNullOrEmpty(newContext))
        {
            return;
        }
        context = newContext;
    }

    /// <summary>
    /// Private helper method for monolog response.
    /// </summary>
    private string RespondMonolog(string ear)
    {
        if (string.IsNullOrEmpty(ear))
        {
            return "";
        }

        string temp = ec.Response(ear);
        if (!string.IsNullOrEmpty(temp))
        {
            context = temp;
        }
        return temp;
    }

    /// <summary>
    /// Learns a new response for the current context.
    /// </summary>
    public void Learn(string ear)
    {
        if (string.IsNullOrEmpty(ear) || ear.Equals(context))
        {
            return;
        }
        ec.AddKeyValue(context, ear);
        context = ear;
    }

    /// <summary>
    /// Returns a monolog based on the current context.
    /// </summary>
    public string Monolog()
    {
        return RespondMonolog(context);
    }

    /// <summary>
    /// Responds to a dialog input.
    /// </summary>
    public string RespondDialog(string ear)
    {
        return ec.Response(ear);
    }

    /// <summary>
    /// Responds to the latest input.
    /// </summary>
    public string RespondLatest(string ear)
    {
        return ec.ResponseLatest(ear);
    }

    /// <summary>
    /// Adds a new key-value pair to the memory.
    /// </summary>
    public void LearnKeyValue(string newContext, string reply)
    {
        ec.AddKeyValue(newContext, reply);
    }

    /// <summary>
    /// Feeds a list of key-value pairs into the memory.
    /// </summary>
    public void FeedKeyValuePairs(System.Collections.Generic.List<AXKeyValuePair> kvList)
    {
        if (kvList.Count == 0)
        {
            return;
        }
        foreach (AXKeyValuePair kv in kvList)
        {
            LearnKeyValue(kv.GetKey(), kv.GetValue());
        }
    }

    /// <summary>
    /// Saves learned data using the provided Kokoro instance.
    /// </summary>
    public void SaveLearnedData(Kokoro kokoro)
    {
        if (elizaWrapper == null)
        {
            return;
        }
        elizaWrapper.SleepNSave(ec, kokoro);
    }

    /// <summary>
    /// Private helper method for loadable monolog mechanics.
    /// </summary>
    private string LoadableMonologMechanics(string ear, Kokoro kokoro)
    {
        if (string.IsNullOrEmpty(ear))
        {
            return "";
        }

        string temp = elizaWrapper!.Respond(ear, ec, kokoro);
        if (!string.IsNullOrEmpty(temp))
        {
            context = temp;
        }
        return temp;
    }

    /// <summary>
    /// Returns a loadable monolog based on the current context.
    /// </summary>
    public string LoadableMonolog(Kokoro kokoro)
    {
        if (elizaWrapper == null)
        {
            return Monolog();
        }
        return LoadableMonologMechanics(context, kokoro);
    }

    /// <summary>
    /// Returns a loadable dialog response.
    /// </summary>
    public string LoadableDialog(string ear, Kokoro kokoro)
    {
        if (elizaWrapper == null)
        {
            return RespondDialog(ear);
        }
        return elizaWrapper.Respond(ear, ec, kokoro);
    }
}

 

[fukurou]

class QuestionChecker {
    private static let QUESTION_WORDS: Set<String> = [
        "what", "who", "where", "when", "why", "how",
        "is", "are", "was", "were", "do", "does", "did",
        "can", "could", "would", "will", "shall", "should",
        "have", "has", "am", "may", "might"
    ]
    
    static func isQuestion(_ input: String) -> Bool {
        let trimmed = input.trimmingCharacters(in: .whitespacesAndNewlines).lowercased()
        
        // Check for empty input
        guard !trimmed.isEmpty else {
            return false
        }
        
        // Check for question mark
        if trimmed.hasSuffix("?") {
            return true
        }
        
        // Extract the first word
        let firstWord: String
        if let firstSpace = trimmed.firstIndex(of: " ") {
            firstWord = String(trimmed[..<firstSpace])
        } else {
            firstWord = trimmed
        }
        
        // Check for contractions like "who's"
        if let apostropheIndex = firstWord.firstIndex(of: "'") {
            let baseWord = String(firstWord[..<apostropheIndex])
            return QUESTION_WORDS.contains(baseWord)
        }
        
        // Check if the first word is a question word
        return QUESTION_WORDS.contains(firstWord)
    }
}

 

[fukurou]

class PhraseInflector {
    // Dictionary for pronoun and verb inflection
    private static let inflectionMap: [String: String] = [
        "i": "you",
        "me": "you",
        "my": "your",
        "mine": "yours",
        "you": "i", // Default inflection
        "your": "my",
        "yours": "mine",
        "am": "are",
        "are": "am",
        "was": "were",
        "were": "was",
        "i'd": "you would",
        "i've": "you have",
        "you've": "I have",
        "you'll": "I will"
    ]
    
    // Function to inflect a phrase
    static func inflectPhrase(_ phrase: String) -> String {
        let words = phrase.split(separator: " ")
        var result = [String]()
        
        for (index, word) in words.enumerated() {
            let lowerWord = word.lowercased()
            var inflectedWord = String(word) // Default to the original word
            
            // Check if the word needs to be inflected
            if let mappedWord = inflectionMap[lowerWord] {
                inflectedWord = mappedWord
                
                // Special case for "you"
                if lowerWord == "you" {
                    // Inflect to "me" if it's at the end of the sentence or after a verb
                    if index == words.count - 1 || (index > 0 && isVerb(String(words[index - 1]).lowercased())) {
                        inflectedWord = "me"
                    } else {
                        inflectedWord = "I"
                    }
                }
            }
            
            // Preserve capitalization
            if let first = word.first, first.isUppercase {
                inflectedWord = inflectedWord.prefix(1).uppercased() + inflectedWord.dropFirst()
            }
            
            result.append(inflectedWord)
        }
        
        return result.joined(separator: " ")
    }
    
    // Helper function to check if a word is a verb
    private static func isVerb(_ word: String) -> Bool {
        return ["am", "are", "was", "were", "have", "has", "had", "do", "does", "did"].contains(word)
    }
}

 

[fukurou]

class RailBot {
    private let ec: EventChatV2
    private var context: String = "stand by"
    private var elizaWrapper: ElizaDBWrapper? = nil // Starts as nil (no DB)

    // Constructor with limit parameter
    init(limit: Int) {
        self.ec = EventChatV2(limit: limit)
    }

    // Default constructor
    convenience init() {
        self.init(limit: 5)
    }

    /// Enables database features. Must be called before any save/load operations.
    /// If never called, RailBot works in memory-only mode.
    func enableDBWrapper() {
        if elizaWrapper == nil {
            elizaWrapper = ElizaDBWrapper()
        }
    }

    /// Disables database features.
    func disableDBWrapper() {
        elizaWrapper = nil
    }

    /// Sets the context.
    func setContext(_ newContext: String) {
        guard !newContext.isEmpty else { return }
        context = newContext
    }

    /// Private helper method for monolog response.
    private func respondMonolog(_ ear: String) -> String {
        guard !ear.isEmpty else { return "" }
        let temp = ec.response(ear: ear)
        if !temp.isEmpty {
            context = temp
        }
        return temp
    }

    /// Learns a new response for the current context.
    func learn(_ ear: String) {
        guard !ear.isEmpty && ear != context else { return }
        ec.addKeyValue(key: context, value: ear)
        context = ear
    }

    /// Returns a monolog based on the current context.
    func monolog() -> String {
        return respondMonolog(context)
    }

    /// Responds to a dialog input.
    func respondDialog(_ ear: String) -> String {
        return ec.response(ear: ear)
    }

    /// Responds to the latest input.
    func respondLatest(_ ear: String) -> String {
        return ec.responseLatest(ear: ear)
    }

    /// Adds a new key-value pair to the memory.
    func learnKeyValue(newContext: String, reply: String) {
        ec.addKeyValue(key: newContext, value: reply)
    }

    /// Feeds a list of key-value pairs into the memory.
    func feedKeyValuePairs(_ kvList: [AXKeyValuePair]) {
        guard !kvList.isEmpty else { return }
        for kv in kvList {
            learnKeyValue(newContext: kv.getKey(), reply: kv.getValue())
        }
    }

    /// Saves learned data using the provided Kokoro instance.
    func saveLearnedData(kokoro: Kokoro) {
        guard let elizaWrapper = elizaWrapper else { return }
        elizaWrapper.sleepNSave(ec: ec, kokoro: kokoro)
    }

    /// Private helper method for loadable monolog mechanics.
    private func loadableMonologMechanics(ear: String, kokoro: Kokoro) -> String {
        guard !ear.isEmpty else { return "" }
        if let temp = elizaWrapper?.respond(ear: ear, ec: ec, kokoro: kokoro), !temp.isEmpty {
            context = temp
        }
        return context
    }

    /// Returns a loadable monolog based on the current context.
    func loadableMonolog(kokoro: Kokoro) -> String {
        guard let elizaWrapper = elizaWrapper else { return monolog() }
        return loadableMonologMechanics(ear: context, kokoro: kokoro)
    }

    /// Returns a loadable dialog response.
    func loadableDialog(ear: String, kokoro: Kokoro) -> String {
        guard let elizaWrapper = elizaWrapper else { return respondDialog(ear) }
        return elizaWrapper.respond(ear: ear, ec: ec, kokoro: kokoro)
    }
}