@qduc/term2 0.7.3 → 0.8.0

package/dist/hooks/use-provider-selection.test.js

@@ -1,15 +1,19 @@
 // @ts-ignore
 globalThis.IS_REACT_ACT_ENVIRONMENT = true;
-import test from 'ava';
+import { it, expect } from 'vitest';
 import React, { act, useEffect } from 'react';
 import { render } from 'ink-testing-library';
 import { useProviderSelection } from './use-provider-selection.js';
-import { InputProvider } from '../context/InputContext.js';
-const TestComponent = ({ settingsService, onHookResult, }) => {
+import { InputProvider, useInputContext } from '../context/InputContext.js';
+const TestComponent = ({ settingsService, onHookResult, onInputValue, }) => {
     const hook = useProviderSelection(settingsService);
+    const { input } = useInputContext();
     useEffect(() => {
         onHookResult(hook);
     });
+    useEffect(() => {
+        onInputValue?.(input);
+    });
     return null;
 };
 const flush = async () => {
@@ -28,7 +32,7 @@ function createMockSettingsService(initialProviders = [], initialActive = 'opena
         setPersistent: (key, value) => settings.set(key, value),
     };
 }
-test.serial('useProviderSelection - lists registered and custom providers on open', async (t) => {
+it.sequential('useProviderSelection - lists registered and custom providers on open', async () => {
     const customProviders = [{ name: 'custom-ollama', type: 'openai-compatible', baseUrl: 'http://localhost:11434/v1' }];
     const settingsService = createMockSettingsService(customProviders, 'openai');
     let hook;
@@ -41,20 +45,20 @@ test.serial('useProviderSelection - lists registered and custom providers on ope
             },
         })));
     });
-    t.true(hook !== undefined);
+    expect(hook !== undefined).toBe(true);
     await act(async () => {
         hook.open();
     });
     await flush();
-    t.is(hook.phase, 'list');
+    expect(hook.phase).toBe('list');
     const items = hook.items;
-    t.true(items.some((item) => item.id === 'openai' && !item.isCustom && item.isActive));
-    t.true(items.some((item) => item.id === 'custom-ollama' && item.isCustom && !item.isActive));
+    expect(items.some((item) => item.id === 'openai' && !item.isCustom && item.isActive)).toBe(true);
+    expect(items.some((item) => item.id === 'custom-ollama' && item.isCustom && !item.isActive)).toBe(true);
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - selecting a custom provider opens edit_fields directly', async (t) => {
+it.sequential('useProviderSelection - selecting a custom provider opens edit_fields directly', async () => {
     const customProviders = [{ name: 'custom-ollama', type: 'openai-compatible', baseUrl: 'http://localhost:11434/v1' }];
     const settingsService = createMockSettingsService(customProviders, 'openai');
     let hook;
@@ -90,15 +94,15 @@ test.serial('useProviderSelection - selecting a custom provider opens edit_field
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'edit_fields');
-    t.is(hook.selectedIndex, 0);
-    t.is(hook.draft?.name, 'custom-ollama');
-    t.is(hook.draft?.baseUrl, 'http://localhost:11434/v1');
+    expect(hook.phase).toBe('edit_fields');
+    expect(hook.selectedIndex).toBe(0);
+    expect(hook.draft?.name).toBe('custom-ollama');
+    expect(hook.draft?.baseUrl).toBe('http://localhost:11434/v1');
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - selecting a built-in provider (except Codex) enters editing flow; Codex is a no-op', async (t) => {
+it.sequential('useProviderSelection - selecting a built-in provider (except Codex) enters editing flow; Codex is a no-op', async () => {
     const settingsService = createMockSettingsService([], 'openai');
     let hook;
     let renderer;
@@ -117,9 +121,9 @@ test.serial('useProviderSelection - selecting a built-in provider (except Codex)
     // Verify Codex is skipped by keyboard navigation
     const active = hook.getActiveItems();
     const codexIdx = active.findIndex((item) => item.kind === 'provider' && item.id === 'codex');
-    t.true(codexIdx !== -1);
+    expect(codexIdx !== -1).toBe(true);
     // Let's verify that navigating moveDown starting from index 0 skips codexIdx
-    t.is(hook.selectedIndex, 0); // Start at OpenAI
+    expect(hook.selectedIndex).toBe(0); // Start at OpenAI
     // Move down a fixed number of times. We should never land on codexIdx!
     const visitedIndices = new Set();
     await act(async () => {
@@ -129,7 +133,7 @@ test.serial('useProviderSelection - selecting a built-in provider (except Codex)
         }
     });
     await flush();
-    t.false(visitedIndices.has(codexIdx), 'Keyboard navigation should skip Codex');
+    expect(visitedIndices.has(codexIdx), 'Keyboard navigation should skip Codex').toBe(false);
     // Navigate to OpenAI (first item, idx 0) and select it
     await act(async () => {
         for (let i = 0; i < active.length; i++) {
@@ -144,37 +148,37 @@ test.serial('useProviderSelection - selecting a built-in provider (except Codex)
     });
     await flush();
     // OpenAI opens edit_fields
-    t.is(hook.phase, 'edit_fields');
-    t.is(hook.selectedIndex, 2); // API Key is selected
-    t.is(hook.draft?.name, 'OpenAI');
+    expect(hook.phase).toBe('edit_fields');
+    expect(hook.selectedIndex).toBe(2); // API Key is selected
+    expect(hook.draft?.name).toBe('OpenAI');
     // Verify we can edit API Key and save it
     await act(async () => {
         hook.selectItem(); // select API Key at index 2
     });
     await flush();
-    t.is(hook.phase, 'wizard_key');
+    expect(hook.phase).toBe('wizard_key');
     await act(async () => {
         hook.handleTextInputSubmit('sk-mock-openai-key');
     });
     await flush();
-    t.is(hook.phase, 'edit_fields');
-    t.is(hook.selectedIndex, 2); // Selected row is API Key row
+    expect(hook.phase).toBe('edit_fields');
+    expect(hook.selectedIndex).toBe(2); // Selected row is API Key row
     await act(async () => {
         hook.moveDown(); // Move to "Save Changes" at index 3
     });
     await flush();
-    t.is(hook.selectedIndex, 3);
+    expect(hook.selectedIndex).toBe(3);
     await act(async () => {
         hook.selectItem(); // Save Changes
     });
     await flush();
-    t.is(hook.phase, 'list');
-    t.is(settingsService.get('agent.openai.apiKey'), 'sk-mock-openai-key');
+    expect(hook.phase).toBe('list');
+    expect(settingsService.get('agent.openai.apiKey')).toBe('sk-mock-openai-key');
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - requestDelete on a custom provider opens confirm_delete', async (t) => {
+it.sequential('useProviderSelection - requestDelete on a custom provider opens confirm_delete', async () => {
     const customProviders = [{ name: 'custom-ollama', type: 'openai-compatible', baseUrl: 'http://localhost:11434/v1' }];
     const settingsService = createMockSettingsService(customProviders, 'openai');
     let hook;
@@ -210,16 +214,16 @@ test.serial('useProviderSelection - requestDelete on a custom provider opens con
         hook.requestDelete();
     });
     await flush();
-    t.is(hook.phase, 'confirm_delete');
+    expect(hook.phase).toBe('confirm_delete');
     // Default cursor should be on "No, keep it" for safety.
-    t.is(hook.selectedIndex, 1);
+    expect(hook.selectedIndex).toBe(1);
     // Confirming "No, keep it" returns to the list.
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'list');
-    t.is(settingsService.get('providers').length, 1);
+    expect(hook.phase).toBe('list');
+    expect(settingsService.get('providers').length).toBe(1);
     // Now request delete again, this time confirm "Yes".
     await act(async () => {
         const active = hook.getActiveItems();
@@ -239,24 +243,24 @@ test.serial('useProviderSelection - requestDelete on a custom provider opens con
         hook.requestDelete();
     });
     await flush();
-    t.is(hook.phase, 'confirm_delete');
+    expect(hook.phase).toBe('confirm_delete');
     await act(async () => {
         hook.moveUp(); // move from default "No" to "Yes"
     });
     await flush();
-    t.is(hook.selectedIndex, 0);
+    expect(hook.selectedIndex).toBe(0);
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'list');
-    t.is(settingsService.get('providers').length, 0);
-    t.is(settingsService.get('agent.provider'), 'openai');
+    expect(hook.phase).toBe('list');
+    expect(settingsService.get('providers').length).toBe(0);
+    expect(settingsService.get('agent.provider')).toBe('openai');
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - requestDelete on a built-in is a no-op', async (t) => {
+it.sequential('useProviderSelection - requestDelete on a built-in is a no-op', async () => {
     const settingsService = createMockSettingsService([], 'openai');
     let hook;
     let renderer;
@@ -277,12 +281,12 @@ test.serial('useProviderSelection - requestDelete on a built-in is a no-op', asy
         hook.requestDelete();
     });
     await flush();
-    t.is(hook.phase, 'list');
+    expect(hook.phase).toBe('list');
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - add provider wizard flow and validation', async (t) => {
+it.sequential('useProviderSelection - add provider wizard flow and validation', async () => {
     const settingsService = createMockSettingsService([], 'openai');
     let hook;
     let renderer;
@@ -317,90 +321,62 @@ test.serial('useProviderSelection - add provider wizard flow and validation', as
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_name');
-    // Submit empty name (fails)
+    expect(hook.phase).toBe('wizard_name');
+    // Submit valid name (validation is tested in provider-service.test.ts)
     let success = false;
-    await act(async () => {
-        success = hook.handleTextInputSubmit('');
-    });
-    await flush();
-    t.false(success);
-    t.is(hook.errorMessage, 'Name cannot be empty.');
-    // Submit invalid name format (fails)
-    await act(async () => {
-        success = hook.handleTextInputSubmit('my provider');
-    });
-    await flush();
-    t.false(success);
-    t.is(hook.errorMessage, 'Name must start with a letter or number and contain only letters, numbers, hyphens, underscores, and dots.');
-    // Submit duplicate/built-in name (fails)
-    await act(async () => {
-        success = hook.handleTextInputSubmit('openai');
-    });
-    await flush();
-    t.false(success);
-    t.true(hook.errorMessage.includes('already exists'));
-    // Submit valid name (success)
     await act(async () => {
         success = hook.handleTextInputSubmit('my-custom-provider');
     });
     await flush();
-    t.true(success);
-    t.is(hook.phase, 'wizard_type');
-    t.is(hook.draft?.name, 'my-custom-provider');
+    expect(success).toBe(true);
+    expect(hook.phase).toBe('wizard_type');
+    expect(hook.draft?.name).toBe('my-custom-provider');
     // Select first type (openai-compatible)
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_url');
-    t.is(hook.draft?.type, 'openai-compatible');
-    // Submit invalid URL (fails)
-    await act(async () => {
-        success = hook.handleTextInputSubmit('not-a-url');
-    });
-    await flush();
-    t.false(success);
-    t.is(hook.errorMessage, 'Invalid URL format. Make sure it starts with http:// or https://');
-    // Submit valid URL (success)
+    expect(hook.phase).toBe('wizard_url');
+    expect(hook.draft?.type).toBe('openai-compatible');
+    // Submit valid URL (URL validation is tested in provider-service.test.ts)
     await act(async () => {
         success = hook.handleTextInputSubmit('http://localhost:8000/v1');
     });
     await flush();
-    t.true(success);
-    t.is(hook.phase, 'wizard_key');
-    t.is(hook.draft?.baseUrl, 'http://localhost:8000/v1');
+    expect(success).toBe(true);
+    expect(hook.phase).toBe('wizard_key');
+    expect(hook.draft?.baseUrl).toBe('http://localhost:8000/v1');
     // Submit empty API Key (success)
     await act(async () => {
         success = hook.handleTextInputSubmit('');
     });
     await flush();
-    t.is(hook.phase, 'edit_fields');
+    expect(hook.phase).toBe('edit_fields');
     const editFields = hook.getActiveItems();
     const baseUrlField = editFields.find((item) => item.kind === 'field' && item.label === 'Base URL');
-    t.truthy(baseUrlField);
-    t.is(baseUrlField?.detail, 'http://localhost:8000/v1');
-    t.false(baseUrlField?.detail?.includes('required') ?? false);
+    expect(baseUrlField).toBeTruthy();
+    expect(baseUrlField?.detail).toBe('http://localhost:8000/v1');
+    expect(baseUrlField?.detail?.includes('required') ?? false).toBe(false);
     // Save changes
-    t.is(hook.selectedIndex, 4); // "Save Changes" should be pre-selected
+    expect(hook.selectedIndex).toBe(4); // "Save Changes" should be pre-selected
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'list');
-    t.is(hook.errorMessage, null);
+    expect(hook.phase).toBe('list');
+    expect(hook.errorMessage).toBe(null);
     // Check persisted in settings
     const persisted = settingsService.get('providers');
-    t.true(Array.isArray(persisted));
-    t.is(persisted.length, 1);
-    t.is(persisted[0].name, 'my-custom-provider');
-    t.is(persisted[0].type, 'openai-compatible');
-    t.is(persisted[0].baseUrl, 'http://localhost:8000/v1');
+    expect(Array.isArray(persisted)).toBe(true);
+    expect(persisted.length).toBe(1);
+    expect(persisted[0].name).toBe('my-custom-provider');
+    expect(persisted[0].type).toBe('openai-compatible');
+    expect(persisted[0].baseUrl).toBe('http://localhost:8000/v1');
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - goBack returns wizard fields to the correct phase', async (t) => {
+it.sequential('useProviderSelection - goBack returns wizard fields to the correct phase', async () => {
     const customProviders = [
         { name: 'existing-provider', type: 'openai-compatible', baseUrl: 'http://localhost:11434/v1' },
     ];
@@ -438,26 +414,26 @@ test.serial('useProviderSelection - goBack returns wizard fields to the correct
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'edit_fields');
-    t.is(hook.selectedIndex, 0);
+    expect(hook.phase).toBe('edit_fields');
+    expect(hook.selectedIndex).toBe(0);
     // Enter on the Name field opens the name editor.
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_name');
-    t.is(hook.selectedIndex, 0);
+    expect(hook.phase).toBe('wizard_name');
+    expect(hook.selectedIndex).toBe(0);
     await act(async () => {
         hook.goBack();
     });
     await flush();
-    t.is(hook.phase, 'edit_fields');
-    t.is(hook.selectedIndex, 0);
+    expect(hook.phase).toBe('edit_fields');
+    expect(hook.selectedIndex).toBe(0);
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - confirm discard appears when backing out of a modified wizard', async (t) => {
+it.sequential('useProviderSelection - confirm discard appears when backing out of a modified wizard', async () => {
     const settingsService = createMockSettingsService([], 'openai');
     let hook;
     let renderer;
@@ -491,29 +467,29 @@ test.serial('useProviderSelection - confirm discard appears when backing out of
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_name');
+    expect(hook.phase).toBe('wizard_name');
     await act(async () => {
         hook.handleTextInputSubmit('test-provider');
     });
     await flush();
-    t.is(hook.phase, 'wizard_type');
+    expect(hook.phase).toBe('wizard_type');
     await act(async () => {
         hook.goBack();
     });
     await flush();
-    t.is(hook.phase, 'confirm_discard');
-    t.is(hook.selectedIndex, 1);
+    expect(hook.phase).toBe('confirm_discard');
+    expect(hook.selectedIndex).toBe(1);
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_type');
-    t.is(hook.selectedIndex, 0);
+    expect(hook.phase).toBe('wizard_type');
+    expect(hook.selectedIndex).toBe(0);
     await act(async () => {
         hook.goBack();
     });
     await flush();
-    t.is(hook.phase, 'confirm_discard');
+    expect(hook.phase).toBe('confirm_discard');
     await act(async () => {
         hook.moveUp();
     });
@@ -522,13 +498,13 @@ test.serial('useProviderSelection - confirm discard appears when backing out of
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_name');
-    t.truthy(hook.draft);
+    expect(hook.phase).toBe('wizard_name');
+    expect(hook.draft).toBeTruthy();
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - back out of an unmodified wizard returns directly to the list', async (t) => {
+it.sequential('useProviderSelection - back out of an unmodified wizard returns directly to the list', async () => {
     const settingsService = createMockSettingsService([], 'openai');
     let hook;
     let renderer;
@@ -562,17 +538,17 @@ test.serial('useProviderSelection - back out of an unmodified wizard returns dir
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_name');
+    expect(hook.phase).toBe('wizard_name');
     await act(async () => {
         hook.goBack();
     });
     await flush();
-    t.is(hook.phase, 'list');
+    expect(hook.phase).toBe('list');
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - saveDraft rejects duplicate names discovered after editing starts', async (t) => {
+it.sequential('useProviderSelection - saveDraft rejects duplicate names discovered after editing starts', async () => {
     const settingsService = createMockSettingsService([], 'openai');
     let hook;
     let renderer;
@@ -606,19 +582,19 @@ test.serial('useProviderSelection - saveDraft rejects duplicate names discovered
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_name');
+    expect(hook.phase).toBe('wizard_name');
     let success = false;
     await act(async () => {
         success = hook.handleTextInputSubmit('late-conflict-provider');
     });
     await flush();
-    t.true(success);
+    expect(success).toBe(true);
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_url');
-    t.is(hook.draft?.type, 'openai-compatible');
+    expect(hook.phase).toBe('wizard_url');
+    expect(hook.draft?.type).toBe('openai-compatible');
     await act(async () => {
         hook.handleTextInputSubmit('http://localhost:8000/v1');
     });
@@ -634,15 +610,15 @@ test.serial('useProviderSelection - saveDraft rejects duplicate names discovered
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'edit_fields');
-    t.deepEqual(hook.fieldErrors, { name: "Provider with name 'late-conflict-provider' already exists." });
-    t.is(hook.errorMessage, null);
-    t.is(settingsService.get('providers').length, 1);
+    expect(hook.phase).toBe('edit_fields');
+    expect(hook.fieldErrors).toEqual({ name: "Provider with name 'late-conflict-provider' already exists." });
+    expect(hook.errorMessage).toBe(null);
+    expect(settingsService.get('providers').length).toBe(1);
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - unchanged provider names are allowed when editing', async (t) => {
+it.sequential('useProviderSelection - unchanged provider names are allowed when editing', async () => {
     const customProviders = [
         { name: 'existing-provider', type: 'openai-compatible', baseUrl: 'http://localhost:11434/v1' },
     ];
@@ -685,14 +661,14 @@ test.serial('useProviderSelection - unchanged provider names are allowed when ed
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_name');
+    expect(hook.phase).toBe('wizard_name');
     let success = false;
     await act(async () => {
         success = hook.handleTextInputSubmit('existing-provider');
     });
     await flush();
-    t.true(success);
-    t.is(hook.phase, 'edit_fields');
+    expect(success).toBe(true);
+    expect(hook.phase).toBe('edit_fields');
     await act(async () => {
         hook.moveDown();
         hook.moveDown();
@@ -700,20 +676,20 @@ test.serial('useProviderSelection - unchanged provider names are allowed when ed
         hook.moveDown();
     });
     await flush();
-    t.is(hook.selectedIndex, 4);
+    expect(hook.selectedIndex).toBe(4);
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'list');
-    t.is(hook.errorMessage, null);
-    t.is(settingsService.get('providers').length, 1);
-    t.is(settingsService.get('providers')[0].name, 'existing-provider');
+    expect(hook.phase).toBe('list');
+    expect(hook.errorMessage).toBe(null);
+    expect(settingsService.get('providers').length).toBe(1);
+    expect(settingsService.get('providers')[0].name).toBe('existing-provider');
     await act(async () => {
         renderer.unmount();
     });
 });
-test.serial('useProviderSelection - scrollOffset updates when navigating and resets on phase change', async (t) => {
+it.sequential('useProviderSelection - scrollOffset updates when navigating and resets on phase change', async () => {
     // Create many mock custom providers to exceed the scroll threshold of 10
     const customProviders = Array.from({ length: 15 }, (_, i) => ({
         name: `custom-provider-${i}`,
@@ -735,8 +711,8 @@ test.serial('useProviderSelection - scrollOffset updates when navigating and res
         hook.open();
     });
     await flush();
-    t.is(hook.phase, 'list');
-    t.is(hook.scrollOffset, 0);
+    expect(hook.phase).toBe('list');
+    expect(hook.scrollOffset).toBe(0);
     // Move down 10 times to reach index 11 (the 11th active item)
     await act(async () => {
         for (let i = 0; i < 10; i++) {
@@ -744,15 +720,15 @@ test.serial('useProviderSelection - scrollOffset updates when navigating and res
         }
     });
     await flush();
-    t.is(hook.selectedIndex, 11);
-    t.is(hook.scrollOffset, 2, 'scrollOffset should scroll to 2 when reaching index 11');
+    expect(hook.selectedIndex).toBe(11);
+    expect(hook.scrollOffset).toBe(2); // was: t.is(hook!.scrollOffset, 2, 'scrollOffset should scroll to 2 when reaching index 11')
     // Move down 1 more time to index 12 (the 12th active item)
     await act(async () => {
         hook.moveDown();
     });
     await flush();
-    t.is(hook.selectedIndex, 12);
-    t.is(hook.scrollOffset, 3, 'scrollOffset should scroll to 3 when reaching index 12');
+    expect(hook.selectedIndex).toBe(12);
+    expect(hook.scrollOffset).toBe(3); // was: t.is(hook!.scrollOffset, 3, 'scrollOffset should scroll to 3 when reaching index 12')
     // Move up to index 0 (scrollOffset should sync back)
     await act(async () => {
         for (let i = 0; i < 11; i++) {
@@ -760,8 +736,8 @@ test.serial('useProviderSelection - scrollOffset updates when navigating and res
         }
     });
     await flush();
-    t.is(hook.selectedIndex, 0);
-    t.is(hook.scrollOffset, 0, 'scrollOffset should return to 0 when moving back to the top');
+    expect(hook.selectedIndex).toBe(0);
+    expect(hook.scrollOffset).toBe(0); // was: t.is(hook!.scrollOffset, 0, 'scrollOffset should return to 0 when moving back to the top')
     // Transition to wizard_name phase to verify scrollOffset resets
     // Let's select "Add Custom Provider" which is at the end of the list
     await act(async () => {
@@ -778,14 +754,104 @@ test.serial('useProviderSelection - scrollOffset updates when navigating and res
         }
     });
     await flush();
-    t.is(hook.selectedIndex, hook.items.length);
-    t.true(hook.scrollOffset > 0, 'scrollOffset should be non-zero near the end of the long list');
+    expect(hook.selectedIndex).toBe(hook.items.length);
+    expect(hook.scrollOffset > 0).toBe(true);
+    await act(async () => {
+        hook.selectItem();
+    });
+    await flush();
+    expect(hook.phase).toBe('wizard_name');
+    expect(hook.scrollOffset, 'scrollOffset should reset to 0 when phase changes to wizard_name').toBe(0);
+    await act(async () => {
+        renderer.unmount();
+    });
+});
+it.sequential('useProviderSelection - editing a field from edit_fields populates input with current value', async () => {
+    const customProviders = [
+        { name: 'my-provider', type: 'openai-compatible', baseUrl: 'http://example.com/v1', apiKey: 'secret-key' },
+    ];
+    const settingsService = createMockSettingsService(customProviders, 'openai');
+    let hook;
+    let inputVal = '';
+    let renderer;
+    await act(async () => {
+        renderer = render(React.createElement(InputProvider, {}, React.createElement(TestComponent, {
+            settingsService,
+            onHookResult: (h) => {
+                hook = h;
+            },
+            onInputValue: (v) => {
+                inputVal = v;
+            },
+        })));
+    });
+    await act(async () => {
+        hook.open();
+    });
+    await flush();
+    // Navigate to the custom provider and select it to enter edit_fields
+    await act(async () => {
+        const active = hook.getActiveItems();
+        const targetIdx = active.findIndex((item) => item.kind === 'provider' && item.id === 'my-provider');
+        let moves = 0;
+        for (let i = 0; i < targetIdx; i++) {
+            if (!(active[i].kind === 'provider' && active[i].id === 'codex')) {
+                moves++;
+            }
+        }
+        for (let i = 0; i < moves; i++) {
+            hook.moveDown();
+        }
+    });
+    await flush();
     await act(async () => {
         hook.selectItem();
     });
     await flush();
-    t.is(hook.phase, 'wizard_name');
-    t.is(hook.scrollOffset, 0, 'scrollOffset should reset to 0 when phase changes to wizard_name');
+    expect(hook.phase).toBe('edit_fields');
+    expect(hook.draft?.name).toBe('my-provider');
+    // Test editing Name field (index 0)
+    await act(async () => {
+        hook.selectItem(); // index 0 = Name
+    });
+    await flush();
+    expect(hook.phase).toBe('wizard_name');
+    expect(inputVal, 'input should be populated with current name').toBe('my-provider');
+    // Go back
+    await act(async () => {
+        hook.goBack();
+    });
+    await flush();
+    expect(hook.phase).toBe('edit_fields');
+    // Test editing Base URL field (index 2)
+    await act(async () => {
+        hook.moveDown();
+        hook.moveDown();
+    });
+    await flush();
+    await act(async () => {
+        hook.selectItem(); // index 2 = Base URL
+    });
+    await flush();
+    expect(hook.phase).toBe('wizard_url');
+    expect(inputVal, 'input should be populated with current baseUrl').toBe('http://example.com/v1');
+    // Go back
+    await act(async () => {
+        hook.goBack();
+    });
+    await flush();
+    expect(hook.phase).toBe('edit_fields');
+    // Test editing API Key field (index 3)
+    await act(async () => {
+        hook.moveDown();
+    });
+    await flush();
+    await act(async () => {
+        hook.selectItem(); // index 3 = API Key
+    });
+    await flush();
+    expect(hook.phase).toBe('wizard_key');
+    expect(inputVal, 'input should be populated with current apiKey').toBe('secret-key');
     await act(async () => {
         renderer.unmount();
     });