@geminilight/mindos 0.6.72 → 0.6.73

package/_standalone/__tests__/acp/session.test.ts

@@ -0,0 +1,466 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { AcpRegistryEntry } from '../../lib/acp/types';
+
+// Mock SDK connection that records calls
+let mockInitialize: ReturnType<typeof vi.fn>;
+let mockNewSession: ReturnType<typeof vi.fn>;
+let mockAuthenticate: ReturnType<typeof vi.fn>;
+let mockPrompt: ReturnType<typeof vi.fn>;
+let mockCancel: ReturnType<typeof vi.fn>;
+let mockSetSessionMode: ReturnType<typeof vi.fn>;
+let mockSetSessionConfigOption: ReturnType<typeof vi.fn>;
+let mockUnstableCloseSession: ReturnType<typeof vi.fn>;
+let mockLoadSession: ReturnType<typeof vi.fn>;
+let mockListSessions: ReturnType<typeof vi.fn>;
+let capturedCallbacks: { onSessionUpdate?: (params: unknown) => void } = {};
+
+vi.mock('../../lib/acp/registry', () => ({
+  findAcpAgent: vi.fn(),
+}));
+
+vi.mock('../../lib/acp/subprocess', () => ({
+  spawnAndConnect: vi.fn(() => {
+    capturedCallbacks = {};
+    return {
+      connection: {
+        initialize: mockInitialize,
+        newSession: mockNewSession,
+        authenticate: mockAuthenticate,
+        prompt: mockPrompt,
+        cancel: mockCancel,
+        setSessionMode: mockSetSessionMode,
+        setSessionConfigOption: mockSetSessionConfigOption,
+        unstable_closeSession: mockUnstableCloseSession,
+        loadSession: mockLoadSession,
+        listSessions: mockListSessions,
+        signal: new AbortController().signal,
+        closed: new Promise(() => {}),
+      },
+      callbacks: capturedCallbacks,
+      process: { id: 'test-proc', agentId: 'test-agent', proc: { pid: 12345 }, alive: true },
+    };
+  }),
+  killAgent: vi.fn((p: { alive: boolean }) => { p.alive = false; }),
+}));
+
+import { createSession, createSessionFromEntry, loadSession, listSessions, prompt, promptStream, cancelPrompt, closeSession, setMode, setConfigOption, getSession, getActiveSessions } from '../../lib/acp/session';
+import { findAcpAgent } from '../../lib/acp/registry';
+
+const MOCK_ENTRY: AcpRegistryEntry = {
+  id: 'test-agent',
+  name: 'Test Agent',
+  description: 'A test ACP agent',
+  transport: 'stdio',
+  command: 'test-agent',
+};
+
+describe('ACP Session (SDK-based)', () => {
+  beforeEach(async () => {
+    vi.clearAllMocks();
+    capturedCallbacks = {};
+
+    mockInitialize = vi.fn().mockResolvedValue({ agentCapabilities: {} });
+    mockNewSession = vi.fn().mockResolvedValue({ sessionId: 'agent-ses-1' });
+    mockAuthenticate = vi.fn().mockResolvedValue({});
+    mockPrompt = vi.fn().mockResolvedValue({ stopReason: 'end_turn' });
+    mockCancel = vi.fn().mockResolvedValue(undefined);
+    mockSetSessionMode = vi.fn().mockResolvedValue({});
+    mockSetSessionConfigOption = vi.fn().mockResolvedValue({ configOptions: [] });
+    mockUnstableCloseSession = vi.fn().mockResolvedValue({});
+    mockLoadSession = vi.fn().mockResolvedValue({ sessionId: 'loaded-ses-1' });
+    mockListSessions = vi.fn().mockResolvedValue({ sessions: [] });
+
+    await Promise.allSettled(getActiveSessions().map(s => closeSession(s.id)));
+  });
+
+  describe('createSessionFromEntry', () => {
+    it('creates a session via SDK initialize + newSession', async () => {
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+
+      expect(session).toBeDefined();
+      expect(session.agentId).toBe('test-agent');
+      expect(session.state).toBe('idle');
+      expect(session.id).toContain('ses-test-agent-');
+      expect(mockInitialize).toHaveBeenCalledOnce();
+      expect(mockNewSession).toHaveBeenCalledOnce();
+    });
+
+    it('extracts agentSessionId from SDK newSession response', async () => {
+      mockNewSession.mockResolvedValueOnce({ sessionId: 'agent-assigned-id-123' });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+
+      expect(session.agentSessionId).toBe('agent-assigned-id-123');
+      expect(session.id).toContain('ses-test-agent-');
+      expect(session.id).not.toBe('agent-assigned-id-123');
+    });
+
+    it('parses modes from nested { availableModes: [...] } format', async () => {
+      mockNewSession.mockResolvedValueOnce({
+        sessionId: 'ses-1',
+        modes: {
+          availableModes: [
+            { id: 'default', name: 'Default' },
+            { id: 'code', name: 'Code Mode', description: 'Optimized for coding' },
+          ],
+          currentModeId: 'default',
+        },
+      });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+
+      expect(session.modes).toHaveLength(2);
+      expect(session.modes![0]).toEqual({ id: 'default', name: 'Default', description: undefined });
+      expect(session.modes![1]).toEqual({ id: 'code', name: 'Code Mode', description: 'Optimized for coding' });
+    });
+
+    it('parses modes from flat array format', async () => {
+      mockNewSession.mockResolvedValueOnce({
+        sessionId: 'ses-1',
+        modes: [{ id: 'default', name: 'Default' }],
+      });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      expect(session.modes).toHaveLength(1);
+    });
+
+    it('throws and cleans up on initialize failure', async () => {
+      mockInitialize.mockRejectedValueOnce(new Error('Init failed'));
+
+      await expect(createSessionFromEntry(MOCK_ENTRY)).rejects.toThrow('initialize failed');
+    });
+
+    it('throws on spawn timeout', async () => {
+      mockInitialize.mockRejectedValueOnce(new Error('timeout'));
+
+      await expect(createSessionFromEntry(MOCK_ENTRY)).rejects.toThrow('timeout');
+    });
+
+    it('authenticates when agent declares auth methods', async () => {
+      mockInitialize.mockResolvedValueOnce({
+        agentCapabilities: {},
+        authMethods: [{ id: 'terminal', name: 'Terminal Login' }],
+      });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      expect(session).toBeDefined();
+      expect(mockAuthenticate).toHaveBeenCalledWith({ methodId: 'terminal' });
+    });
+  });
+
+  describe('prompt', () => {
+    it('returns aggregated notification text', async () => {
+      mockPrompt.mockImplementationOnce(async () => {
+        if (capturedCallbacks.onSessionUpdate) {
+          capturedCallbacks.onSessionUpdate({
+            sessionId: 'x',
+            update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'Hello ' } },
+          });
+          capturedCallbacks.onSessionUpdate({
+            sessionId: 'x',
+            update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'world!' } },
+          });
+        }
+        return { stopReason: 'end_turn' };
+      });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      const response = await prompt(session.id, 'Hello');
+
+      expect(response.text).toBe('Hello world!');
+      expect(response.done).toBe(true);
+      expect(response.stopReason).toBe('end_turn');
+    });
+
+    it('uses agentSessionId in SDK prompt call', async () => {
+      mockNewSession.mockResolvedValueOnce({ sessionId: 'agent-ses-42' });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await prompt(session.id, 'test');
+
+      expect(mockPrompt).toHaveBeenCalledWith(expect.objectContaining({
+        sessionId: 'agent-ses-42',
+      }));
+    });
+
+    it('throws for unknown session', async () => {
+      await expect(prompt('nonexistent', 'hello')).rejects.toThrow('Session not found');
+    });
+
+    it('sets session state to error on prompt failure', async () => {
+      mockPrompt.mockRejectedValueOnce(new Error('Agent crashed'));
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await expect(prompt(session.id, 'crash')).rejects.toThrow('Agent crashed');
+      expect(getSession(session.id)?.state).toBe('error');
+    });
+
+    it('cleans up update handler after prompt (success)', async () => {
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await prompt(session.id, 'test');
+      expect(capturedCallbacks.onSessionUpdate).toBeUndefined();
+    });
+
+    it('cleans up update handler after prompt (error)', async () => {
+      mockPrompt.mockRejectedValueOnce(new Error('fail'));
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await expect(prompt(session.id, 'test')).rejects.toThrow('fail');
+      expect(capturedCallbacks.onSessionUpdate).toBeUndefined();
+    });
+
+    it('rejects concurrent prompts on same session', async () => {
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      mockPrompt.mockImplementationOnce(() => new Promise(() => {})); // never resolves
+      const p1 = prompt(session.id, 'first');
+      await expect(prompt(session.id, 'second')).rejects.toThrow('busy');
+      // Clean up the hanging prompt
+      session.state = 'idle';
+    });
+  });
+
+  describe('promptStream', () => {
+    it('forwards updates via onUpdate callback', async () => {
+      const updates: unknown[] = [];
+
+      mockPrompt.mockImplementationOnce(async () => {
+        if (capturedCallbacks.onSessionUpdate) {
+          capturedCallbacks.onSessionUpdate({
+            sessionId: 'x',
+            update: { sessionUpdate: 'agent_message_chunk', content: { type: 'text', text: 'streaming...' } },
+          });
+        }
+        return { stopReason: 'end_turn' };
+      });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      const response = await promptStream(session.id, 'Hello', (update) => updates.push(update));
+
+      expect(response.text).toBe('streaming...');
+      expect(updates.length).toBeGreaterThanOrEqual(1);
+      expect(updates[updates.length - 1]).toEqual(expect.objectContaining({ type: 'done' }));
+    });
+  });
+
+  describe('cancelPrompt', () => {
+    it('does nothing for idle session', async () => {
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await cancelPrompt(session.id);
+      expect(getSession(session.id)?.state).toBe('idle');
+      expect(mockCancel).not.toHaveBeenCalled();
+    });
+
+    it('throws for unknown session', async () => {
+      await expect(cancelPrompt('nonexistent')).rejects.toThrow('Session not found');
+    });
+  });
+
+  describe('setMode', () => {
+    it('calls SDK setSessionMode with wireSessionId', async () => {
+      mockNewSession.mockResolvedValueOnce({ sessionId: 'agent-ses-99' });
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+
+      await setMode(session.id, 'code');
+
+      expect(mockSetSessionMode).toHaveBeenCalledWith({
+        sessionId: 'agent-ses-99',
+        modeId: 'code',
+      });
+    });
+  });
+
+  describe('setConfigOption', () => {
+    it('calls SDK setSessionConfigOption and returns updated options', async () => {
+      mockSetSessionConfigOption.mockResolvedValueOnce({
+        configOptions: [
+          { configId: 'model', category: 'model', currentValue: 'gpt-4', options: [] },
+        ],
+      });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      const result = await setConfigOption(session.id, 'model', 'gpt-4');
+
+      expect(result).toHaveLength(1);
+      expect(result[0].configId).toBe('model');
+    });
+  });
+
+  describe('closeSession', () => {
+    it('closes and removes session', async () => {
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await closeSession(session.id);
+      expect(getSession(session.id)).toBeUndefined();
+    });
+
+    it('handles close of nonexistent session gracefully', async () => {
+      await closeSession('nonexistent');
+    });
+
+    it('calls unstable_closeSession on SDK connection', async () => {
+      mockNewSession.mockResolvedValueOnce({ sessionId: 'agent-ses-close' });
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await closeSession(session.id);
+
+      expect(mockUnstableCloseSession).toHaveBeenCalledWith({
+        sessionId: 'agent-ses-close',
+      });
+    });
+  });
+
+  describe('getActiveSessions', () => {
+    it('returns empty initially', () => {
+      expect(getActiveSessions()).toHaveLength(0);
+    });
+  });
+
+  describe('createSession (by agentId)', () => {
+    it('throws when agent is not found in registry', async () => {
+      (findAcpAgent as ReturnType<typeof vi.fn>).mockResolvedValueOnce(null);
+      await expect(createSession('nonexistent-agent')).rejects.toThrow('not found in registry');
+    });
+
+    it('delegates to createSessionFromEntry when agent is found', async () => {
+      (findAcpAgent as ReturnType<typeof vi.fn>).mockResolvedValueOnce(MOCK_ENTRY);
+      const session = await createSession('test-agent');
+      expect(session.agentId).toBe('test-agent');
+    });
+  });
+
+  describe('createSessionFromEntry — edge cases', () => {
+    it('continues when session/new fails with non-auth error', async () => {
+      mockNewSession.mockRejectedValueOnce(new Error('Network timeout'));
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      expect(session).toBeDefined();
+      expect(session.agentSessionId).toBeUndefined();
+    });
+
+    it('throws when session/new fails with auth error', async () => {
+      mockNewSession.mockRejectedValueOnce(new Error('Authentication required'));
+      await expect(createSessionFromEntry(MOCK_ENTRY)).rejects.toThrow('Authentication required');
+    });
+
+    it('enforces max total sessions limit', async () => {
+      const created: string[] = [];
+      for (let i = 0; i < 10; i++) {
+        const s = await createSessionFromEntry({
+          ...MOCK_ENTRY,
+          id: `agent-${i}`,
+        });
+        created.push(s.id);
+      }
+      await expect(createSessionFromEntry({ ...MOCK_ENTRY, id: 'agent-overflow' })).rejects.toThrow('Maximum concurrent sessions');
+      for (const id of created) await closeSession(id);
+    });
+
+    it('enforces per-agent limit when filling total limit', async () => {
+      const created: string[] = [];
+      // Create 3 sessions for same agent (fills per-agent limit)
+      for (let i = 0; i < 3; i++) {
+        const s = await createSessionFromEntry(MOCK_ENTRY);
+        created.push(s.id);
+      }
+      // 4th session with different agent should succeed
+      const s4 = await createSessionFromEntry({ ...MOCK_ENTRY, id: 'other-agent' });
+      created.push(s4.id);
+      expect(s4.agentId).toBe('other-agent');
+      for (const id of created) await closeSession(id);
+    });
+
+    it('parses config options from session/new response', async () => {
+      mockNewSession.mockResolvedValueOnce({
+        sessionId: 'ses-cfg',
+        configOptions: [
+          { configId: 'model', category: 'model', currentValue: 'gpt-4', options: [{ id: 'gpt-4', label: 'GPT-4' }] },
+        ],
+      });
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      expect(session.configOptions).toHaveLength(1);
+      expect(session.configOptions![0].configId).toBe('model');
+    });
+  });
+
+  describe('loadSession', () => {
+    it('throws when agent is not found', async () => {
+      (findAcpAgent as ReturnType<typeof vi.fn>).mockResolvedValueOnce(null);
+      await expect(loadSession('unknown', 'ses-1')).rejects.toThrow('not found in registry');
+    });
+
+    it('throws when agent does not support loadSession', async () => {
+      (findAcpAgent as ReturnType<typeof vi.fn>).mockResolvedValueOnce(MOCK_ENTRY);
+      mockInitialize.mockResolvedValueOnce({ agentCapabilities: { loadSession: false } });
+      await expect(loadSession('test-agent', 'ses-1')).rejects.toThrow('does not support session/load');
+    });
+
+    it('loads session when agent supports it', async () => {
+      (findAcpAgent as ReturnType<typeof vi.fn>).mockResolvedValueOnce(MOCK_ENTRY);
+      mockInitialize.mockResolvedValueOnce({ agentCapabilities: { loadSession: true } });
+      mockLoadSession.mockResolvedValueOnce({ sessionId: 'ses-loaded', modes: [] });
+      const session = await loadSession('test-agent', 'ses-loaded');
+      expect(session.agentSessionId).toBe('ses-loaded');
+    });
+  });
+
+  describe('listSessions', () => {
+    it('throws when agent does not support session/list', async () => {
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await expect(listSessions(session.id)).rejects.toThrow('does not support session/list');
+    });
+
+    it('returns sessions when supported', async () => {
+      mockInitialize.mockResolvedValueOnce({
+        agentCapabilities: { sessionCapabilities: { list: true } },
+      });
+      mockListSessions.mockResolvedValueOnce({
+        sessions: [{ sessionId: 'ses-1', cwd: '/home', title: 'My Session' }],
+        nextCursor: 'abc',
+      });
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      const result = await listSessions(session.id);
+      expect(result.sessions).toHaveLength(1);
+      expect(result.sessions[0].sessionId).toBe('ses-1');
+      expect(result.nextCursor).toBe('abc');
+    });
+  });
+
+  describe('prompt — notification types', () => {
+    it('aggregates thinking content as text', async () => {
+      mockPrompt.mockImplementationOnce(async () => {
+        if (capturedCallbacks.onSessionUpdate) {
+          capturedCallbacks.onSessionUpdate({
+            sessionId: 'x',
+            update: { sessionUpdate: 'agent_thought_chunk', content: { type: 'thinking', text: 'hmm...' } },
+          });
+        }
+        return { stopReason: 'end_turn' };
+      });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      const response = await prompt(session.id, 'think');
+      expect(response.text).toBe('');
+    });
+
+    it('handles tool_call notifications in promptStream', async () => {
+      const updates: unknown[] = [];
+      mockPrompt.mockImplementationOnce(async () => {
+        if (capturedCallbacks.onSessionUpdate) {
+          capturedCallbacks.onSessionUpdate({
+            sessionId: 'x',
+            update: {
+              sessionUpdate: 'tool_call',
+              toolCallId: 'tc-1',
+              title: 'Read file',
+              status: 'completed',
+              kind: 'read',
+            },
+          });
+        }
+        return { stopReason: 'end_turn' };
+      });
+
+      const session = await createSessionFromEntry(MOCK_ENTRY);
+      await promptStream(session.id, 'do something', (u) => updates.push(u));
+      const toolUpdate = updates.find((u: any) => u.type === 'tool_call');
+      expect(toolUpdate).toBeDefined();
+    });
+  });
+});

package/_standalone/__tests__/agent/backend-retry.test.ts

@@ -0,0 +1,143 @@
+/**
+ * Tests for backend retry logic in route.ts (non-ACP path).
+ *
+ * We test the pure helper functions involved:
+ * - isTransientError (route.ts currently uses this for backend LLM retry)
+ * - The retry loop semantics are validated via unit tests of the helper
+ */
+import { describe, it, expect } from 'vitest';
+import { isTransientError } from '@/lib/agent/retry';
+
+describe('isTransientError (backend LLM retry guard)', () => {
+  describe('timeout errors', () => {
+    it('detects "timeout" keyword', () => {
+      expect(isTransientError(new Error('Request timeout after 30s'))).toBe(true);
+    });
+
+    it('detects "timed out" keyword', () => {
+      expect(isTransientError(new Error('Connection timed out'))).toBe(true);
+    });
+
+    it('detects "ETIMEDOUT" (case insensitive)', () => {
+      expect(isTransientError(new Error('ETIMEDOUT'))).toBe(true);
+    });
+  });
+
+  describe('rate limit errors', () => {
+    it('detects "429" in message', () => {
+      expect(isTransientError(new Error('Error 429: rate limit exceeded'))).toBe(true);
+    });
+
+    it('detects "rate limit" keyword', () => {
+      expect(isTransientError(new Error('Rate limit reached for model'))).toBe(true);
+    });
+
+    it('detects "too many requests"', () => {
+      expect(isTransientError(new Error('Too many requests'))).toBe(true);
+    });
+  });
+
+  describe('server errors (5xx)', () => {
+    it('detects "500" in message', () => {
+      expect(isTransientError(new Error('500 Internal Server Error'))).toBe(true);
+    });
+
+    it('detects "503" in message', () => {
+      expect(isTransientError(new Error('503 Service Unavailable'))).toBe(true);
+    });
+
+    it('detects "overloaded"', () => {
+      expect(isTransientError(new Error('Model is currently overloaded'))).toBe(true);
+    });
+  });
+
+  describe('connection errors', () => {
+    it('detects ECONNRESET', () => {
+      expect(isTransientError(new Error('read ECONNRESET'))).toBe(true);
+    });
+
+    it('detects "socket hang up"', () => {
+      expect(isTransientError(new Error('socket hang up'))).toBe(true);
+    });
+  });
+
+  describe('non-retryable errors', () => {
+    it('returns false for auth errors', () => {
+      expect(isTransientError(new Error('Invalid API key'))).toBe(false);
+    });
+
+    it('returns false for generic errors without transient keywords', () => {
+      expect(isTransientError(new Error('Something went wrong'))).toBe(false);
+    });
+
+    it('returns false for content policy violations', () => {
+      expect(isTransientError(new Error('Your request was rejected due to content policy'))).toBe(false);
+    });
+  });
+});
+
+// ── Retry loop semantics ──────────────────────────────────────────────────────
+// These tests validate the CORRECT behavior after fixing the off-by-one bug.
+// The loop should attempt: attempt=1, attempt=2, attempt=3 (MAX_RETRIES=3)
+// with retries happening when attempt < MAX_RETRIES (i.e., on attempts 1 and 2)
+
+describe('retry loop semantics (backend route.ts)', () => {
+  /**
+   * Simulates the corrected retry loop from route.ts.
+   * Returns how many attempts were made before success or giving up.
+   */
+  function simulateRetryLoop(
+    shouldFailOn: number[], // attempt numbers that should throw
+    hasContent = false,
+    MAX_RETRIES = 3,
+  ): { attempts: number; succeeded: boolean } {
+    let attempts = 0;
+    let lastError: Error | null = null;
+
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+      attempts++;
+      if (shouldFailOn.includes(attempt)) {
+        lastError = new Error('Request timeout after 30s');
+        // attempt < MAX_RETRIES: on final attempt, canRetry=false → throws immediately
+        const canRetry = !hasContent && attempt < MAX_RETRIES && isTransientError(lastError);
+        if (!canRetry) break;
+        // would sleep here in real code
+      } else {
+        lastError = null;
+        break; // success
+      }
+    }
+
+    return { attempts, succeeded: lastError === null };
+  }
+
+  it('succeeds on first attempt with 1 attempt total', () => {
+    const { attempts, succeeded } = simulateRetryLoop([]);
+    expect(attempts).toBe(1);
+    expect(succeeded).toBe(true);
+  });
+
+  it('retries once after first failure, succeeds on second attempt', () => {
+    const { attempts, succeeded } = simulateRetryLoop([1]);
+    expect(attempts).toBe(2);
+    expect(succeeded).toBe(true);
+  });
+
+  it('retries twice after two failures, succeeds on third attempt', () => {
+    const { attempts, succeeded } = simulateRetryLoop([1, 2]);
+    expect(attempts).toBe(3);
+    expect(succeeded).toBe(true);
+  });
+
+  it('fails after MAX_RETRIES (3) consecutive failures', () => {
+    const { attempts, succeeded } = simulateRetryLoop([1, 2, 3]);
+    expect(attempts).toBe(3);
+    expect(succeeded).toBe(false);
+  });
+
+  it('does NOT retry if content has already been streamed', () => {
+    const { attempts, succeeded } = simulateRetryLoop([1, 2, 3], true /* hasContent=true */);
+    expect(attempts).toBe(1);
+    expect(succeeded).toBe(false);
+  });
+});