@@ -1725,3 +1725,249 @@ func TestCanAcceptMessages(t *testing.T) {
17251725 })
17261726 }
17271727 }
1728+
1729+func TestSendEphemeralMessage_IdleState(t *testing.T) {
1730+ s, bus, cleanup := setupMysisTest(t)
1731+ defer cleanup()
1732+
1733+ // Create stored mysis
1734+ stored, err := s.CreateMysis("ephemeral-idle-test", "mock", "test-model", 0.7)
1735+ if err != nil {
1736+ t.Fatalf("CreateMysis() error: %v", err)
1737+ }
1738+
1739+ mock := provider.NewMock("mock", "response")
1740+ mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
1741+
1742+ // Mysis starts in idle state
1743+ if mysis.State() != MysisStateIdle {
1744+ t.Fatalf("expected idle state, got %s", mysis.State())
1745+ }
1746+
1747+ // Should be able to send ephemeral message to idle mysis
1748+ err = mysis.SendEphemeralMessage("ephemeral test", store.MemorySourceDirect)
1749+ if err != nil {
1750+ t.Errorf("should accept ephemeral message in idle state, got error: %v", err)
1751+ }
1752+}
1753+
1754+func TestSendEphemeralMessage_StoppedState(t *testing.T) {
1755+ s, bus, cleanup := setupMysisTest(t)
1756+ defer cleanup()
1757+
1758+ // Create stored mysis
1759+ stored, err := s.CreateMysis("ephemeral-stopped-test", "mock", "test-model", 0.7)
1760+ if err != nil {
1761+ t.Fatalf("CreateMysis() error: %v", err)
1762+ }
1763+
1764+ mock := provider.NewMock("mock", "response")
1765+ mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
1766+
1767+ // Start then stop
1768+ if err := mysis.Start(); err != nil {
1769+ t.Fatalf("failed to start: %v", err)
1770+ }
1771+ if err := mysis.Stop(); err != nil {
1772+ t.Fatalf("failed to stop: %v", err)
1773+ }
1774+
1775+ if mysis.State() != MysisStateStopped {
1776+ t.Fatalf("expected stopped state, got %s", mysis.State())
1777+ }
1778+
1779+ // Should reject ephemeral message in stopped state
1780+ err = mysis.SendEphemeralMessage("ephemeral test", store.MemorySourceDirect)
1781+ if err == nil {
1782+ t.Error("should reject ephemeral message in stopped state")
1783+ }
1784+ if !strings.Contains(err.Error(), "stopped") {
1785+ t.Errorf("error should mention stopped, got: %v", err)
1786+ }
1787+}
1788+
1789+// setupTestMysis creates a mysis for testing with a mock provider
1790+func setupTestMysis(t *testing.T) (*Mysis, func()) {
1791+ t.Helper()
1792+
1793+ s, bus, cleanup := setupMysisTest(t)
1794+
1795+ stored, err := s.CreateMysis("test-mysis", "mock", "test-model", 0.7)
1796+ if err != nil {
1797+ t.Fatalf("CreateMysis() error: %v", err)
1798+ }
1799+
1800+ mock := provider.NewMock("mock", "test response")
1801+ mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
1802+
1803+ return mysis, cleanup
1804+}
1805+
1806+// setupTestMysisWithErrorProvider creates a mysis with a provider that returns errors
1807+func setupTestMysisWithErrorProvider(t *testing.T) (*Mysis, func()) {
1808+ t.Helper()
1809+
1810+ s, bus, cleanup := setupMysisTest(t)
1811+
1812+ stored, err := s.CreateMysis("error-mysis", "mock", "test-model", 0.7)
1813+ if err != nil {
1814+ t.Fatalf("CreateMysis() error: %v", err)
1815+ }
1816+
1817+ // Create a mock provider that returns errors
1818+ mock := provider.NewMock("mock", "").WithChatError(errors.New("provider error"))
1819+ mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
1820+
1821+ return mysis, cleanup
1822+}
1823+
1824+func TestSendMessageFrom_IdleState(t *testing.T) {
1825+ mysis, cleanup := setupTestMysis(t)
1826+ defer cleanup()
1827+
1828+ // Mysis starts in idle state
1829+ if mysis.State() != MysisStateIdle {
1830+ t.Fatalf("expected idle state, got %s", mysis.State())
1831+ }
1832+
1833+ // Should be able to send message to idle mysis
1834+ err := mysis.SendMessageFrom("test message", store.MemorySourceDirect, "")
1835+ if err != nil {
1836+ t.Errorf("should accept message in idle state, got error: %v", err)
1837+ }
1838+
1839+ // Verify message was stored
1840+ memories, err := mysis.store.GetMemories(mysis.ID())
1841+ if err != nil {
1842+ t.Fatalf("failed to get memories: %v", err)
1843+ }
1844+ if len(memories) == 0 {
1845+ t.Error("message was not stored")
1846+ }
1847+ if len(memories) == 0 {
1848+ t.Error("message was not stored")
1849+ }
1850+}
1851+
1852+func TestSendMessageFrom_StoppedState(t *testing.T) {
1853+ mysis, cleanup := setupTestMysis(t)
1854+ defer cleanup()
1855+
1856+ // Start then stop the mysis
1857+ if err := mysis.Start(); err != nil {
1858+ t.Fatalf("failed to start mysis: %v", err)
1859+ }
1860+ if err := mysis.Stop(); err != nil {
1861+ t.Fatalf("failed to stop mysis: %v", err)
1862+ }
1863+
1864+ if mysis.State() != MysisStateStopped {
1865+ t.Fatalf("expected stopped state, got %s", mysis.State())
1866+ }
1867+
1868+ // Should NOT be able to send message to stopped mysis
1869+ err := mysis.SendMessageFrom("test message", store.MemorySourceDirect, "")
1870+ if err == nil {
1871+ t.Error("should reject message in stopped state")
1872+ }
1873+ if !strings.Contains(err.Error(), "stopped") || !strings.Contains(err.Error(), "relaunch") {
1874+ t.Errorf("error should mention stopped and relaunch, got: %v", err)
1875+ }
1876+}
1877+
1878+func TestSendMessageFrom_ErroredState(t *testing.T) {
1879+ mysis, cleanup := setupTestMysisWithErrorProvider(t)
1880+ defer cleanup()
1881+
1882+ // Start mysis and trigger error
1883+ if err := mysis.Start(); err != nil {
1884+ t.Fatalf("failed to start mysis: %v", err)
1885+ }
1886+
1887+ // Send message to trigger error
1888+ _ = mysis.SendMessageFrom("trigger error", store.MemorySourceDirect, "")
1889+
1890+ // Wait for error state
1891+ time.Sleep(100 * time.Millisecond)
1892+
1893+ if mysis.State() != MysisStateErrored {
1894+ t.Fatalf("expected errored state, got %s", mysis.State())
1895+ }
1896+
1897+ // Should NOT be able to send message to errored mysis
1898+ err := mysis.SendMessageFrom("test message", store.MemorySourceDirect, "")
1899+ if err == nil {
1900+ t.Error("should reject message in errored state")
1901+ }
1902+ if !strings.Contains(err.Error(), "errored") || !strings.Contains(err.Error(), "relaunch") {
1903+ t.Errorf("error should mention errored and relaunch, got: %v", err)
1904+ }
1905+}
1906+func TestQueueBroadcast_IdleState(t *testing.T) {
1907+ s, bus, cleanup := setupMysisTest(t)
1908+ defer cleanup()
1909+
1910+ // Create stored mysis
1911+ stored, err := s.CreateMysis("test-mysis", "mock", "test-model", 0.7)
1912+ if err != nil {
1913+ t.Fatalf("CreateMysis() error: %v", err)
1914+ }
1915+
1916+ mock := provider.NewMock("mock", "Hello!")
1917+ mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
1918+
1919+ // Mysis starts in idle state
1920+ if mysis.State() != MysisStateIdle {
1921+ t.Fatalf("expected idle state, got %s", mysis.State())
1922+ }
1923+
1924+ // Should be able to queue broadcast to idle mysis
1925+ err = mysis.QueueBroadcast("broadcast test", "sender-id")
1926+ if err != nil {
1927+ t.Errorf("should accept broadcast in idle state, got error: %v", err)
1928+ }
1929+
1930+ // Verify message was stored
1931+ memories, err := s.GetMemories(mysis.ID())
1932+ if err != nil {
1933+ t.Fatalf("failed to get memories: %v", err)
1934+ }
1935+ if len(memories) == 0 {
1936+ t.Error("broadcast was not stored")
1937+ }
1938+}
1939+
1940+func TestQueueBroadcast_StoppedState(t *testing.T) {
1941+ s, bus, cleanup := setupMysisTest(t)
1942+ defer cleanup()
1943+
1944+ // Create stored mysis
1945+ stored, err := s.CreateMysis("test-mysis", "mock", "test-model", 0.7)
1946+ if err != nil {
1947+ t.Fatalf("CreateMysis() error: %v", err)
1948+ }
1949+
1950+ mock := provider.NewMock("mock", "Hello!")
1951+ mysis := NewMysis(stored.ID, stored.Name, stored.CreatedAt, mock, s, bus)
1952+
1953+ // Start then stop
1954+ if err := mysis.Start(); err != nil {
1955+ t.Fatalf("failed to start: %v", err)
1956+ }
1957+ if err := mysis.Stop(); err != nil {
1958+ t.Fatalf("failed to stop: %v", err)
1959+ }
1960+
1961+ if mysis.State() != MysisStateStopped {
1962+ t.Fatalf("expected stopped state, got %s", mysis.State())
1963+ }
1964+
1965+ // Should reject broadcast in stopped state
1966+ err = mysis.QueueBroadcast("broadcast test", "sender-id")
1967+ if err == nil {
1968+ t.Error("should reject broadcast in stopped state")
1969+ }
1970+ if !strings.Contains(err.Error(), "stopped") {
1971+ t.Errorf("error should mention stopped, got: %v", err)
1972+ }
1973+}