@sean.holung/minicode 0.3.7 → 0.3.8

package/dist/src/web/index.html

@@ -27,6 +27,10 @@
         <div class="model-menu">
           <button id="model-btn" class="header-btn" title="Switch model"><span id="model-info"></span> ▾</button>
           <div id="model-dropdown" class="dropdown hidden">
+            <div class="dropdown-section dropdown-search-section">
+              <input id="model-search" type="text" placeholder="Search models..." autocomplete="off" />
+            </div>
+            <div class="dropdown-divider"></div>
             <div id="model-list" class="dropdown-section">
               <div class="dropdown-empty">Loading models...</div>
             </div>
@@ -61,15 +65,28 @@
           <div class="config-overlay-content">
             <h2>Agent not connected</h2>
             <p id="config-missing" class="config-missing hidden"></p>
-            <div id="config-overlay-spotlight" class="config-overlay-spotlight">
-              <div class="config-overlay-spotlight-copy">
-                <span class="config-overlay-spotlight-badge">Fastest way to start</span>
-                <strong>Try minicode for free with OpenRouter</strong>
-                <p>Create a free OpenRouter account, connect it to this <code>minicode serve</code> session, and use free models without editing config files first.</p>
+            <div id="config-overlay-quick-connects" class="config-overlay-shortcuts">
+              <div id="config-overlay-spotlight" class="config-overlay-spotlight">
+                <div class="config-overlay-spotlight-copy">
+                  <span class="config-overlay-spotlight-badge">Fastest way to start</span>
+                  <strong>Try minicode for free with OpenRouter</strong>
+                  <p>Create a free OpenRouter account, connect it to this <code>minicode serve</code> session, and use free models without editing config files first.</p>
+                </div>
+                <div class="config-overlay-actions config-overlay-spotlight-actions">
+                  <button id="connect-openrouter-btn" class="dropdown-action" type="button" data-openrouter-connect="true">Connect OpenRouter</button>
+                </div>
               </div>
-              <div class="config-overlay-actions config-overlay-spotlight-actions">
-                <button id="connect-openrouter-btn" class="dropdown-action" type="button" data-openrouter-connect="true">Connect OpenRouter</button>
-                <span class="config-overlay-action-note">Session-only. Nothing is written to disk.</span>
+
+              <div id="config-overlay-openai-compatible" class="config-overlay-spotlight config-overlay-spotlight-secondary">
+                <div class="config-overlay-spotlight-copy">
+                  <span class="config-overlay-spotlight-badge">Local quick connect</span>
+                  <strong>Connect OpenAI-compatible</strong>
+                  <p>Choose a preset like LM Studio, OpenAI, Ollama, or Custom, then adjust the endpoint if needed before connecting this <code>minicode serve</code> session.</p>
+                </div>
+                <div class="config-overlay-actions config-overlay-spotlight-actions">
+                  <button id="connect-openai-compatible-btn" class="dropdown-action" type="button" data-openai-compatible-connect="true">Connect OpenAI-compatible</button>
+                  <span class="config-overlay-action-note">Starts with common presets, but the endpoint stays editable.</span>
+                </div>
               </div>
             </div>
             <p id="config-overlay-intro">minicode needs a model provider to run. Configure one of the following:</p>
@@ -115,6 +132,7 @@ MODEL=your-model-name</pre>
         <div id="graph-toolbar">
           <input id="graph-search" type="text" placeholder="Search symbols or files..." autocomplete="off" />
           <button id="graph-analyze" class="header-btn">Analyze</button>
+          <button id="graph-refresh" class="header-btn" title="Refresh the dependency graph and symbol search">Refresh</button>
           <button id="graph-fit" class="header-btn">Fit</button>
           <button id="graph-relayout" class="header-btn">Re-layout</button>
           <button id="graph-clear" class="header-btn">Clear</button>
@@ -176,6 +194,23 @@ MODEL=your-model-name</pre>
         </div>
         <button id="disconnect-openrouter-btn" class="header-btn" type="button">Disconnect OpenRouter</button>
       </div>
+      <div id="settings-openai-compatible-session" class="settings-session-banner hidden" role="status" aria-live="polite">
+        <div class="settings-session-copy">
+          <div class="settings-session-title">OpenAI-compatible provider is connected for this serve session</div>
+          <div id="settings-openai-compatible-session-meta" class="settings-session-meta"></div>
+        </div>
+        <button id="disconnect-openai-compatible-btn" class="header-btn" type="button">Disconnect OpenAI-compatible</button>
+      </div>
+      <div class="settings-provider-shortcuts">
+        <div class="settings-provider-shortcuts-copy">
+          <div class="settings-session-title">Quick connect</div>
+          <div class="settings-session-meta">Temporarily connect a provider for this serve session, or optionally save it to <code>~/.minicode/.env</code>.</div>
+        </div>
+        <div class="settings-provider-shortcuts-actions">
+          <button class="header-btn" type="button" data-openrouter-connect="true">Connect OpenRouter</button>
+          <button class="header-btn" type="button" data-openai-compatible-connect="true">Connect OpenAI-compatible</button>
+        </div>
+      </div>
       <div id="settings-list" class="settings-list">
         <div class="dropdown-empty">Loading settings...</div>
       </div>
@@ -235,6 +270,75 @@ MODEL=your-model-name</pre>
     </section>
   </div>
 
+  <div id="openai-compatible-connect-modal" class="modal hidden" aria-hidden="true">
+    <div id="openai-compatible-connect-backdrop" class="modal-backdrop"></div>
+    <section class="modal-panel modal-panel-compact" role="dialog" aria-modal="true" aria-labelledby="openai-compatible-connect-title">
+      <div class="modal-header">
+        <div>
+          <h2 id="openai-compatible-connect-title">Connect OpenAI-compatible</h2>
+          <p class="modal-subtitle">Configure an OpenAI-compatible endpoint for this <code>minicode serve</code> session and optionally save it for future runs.</p>
+        </div>
+        <button id="openai-compatible-connect-close" class="header-btn" type="button">Close</button>
+      </div>
+
+      <div class="openrouter-connect-body">
+        <p class="openrouter-connect-lead">
+          Pick a preset to prefill a common endpoint, then adjust it if needed. minicode will point this serve session at the OpenAI-compatible API endpoint you provide.
+        </p>
+
+        <div class="openrouter-connect-note">
+          <strong>Connection details</strong>
+          <p>Local runtimes like LM Studio or Ollama usually work without an API key, while hosted providers like OpenAI typically require one. The endpoint stays editable no matter which preset you choose.</p>
+        </div>
+
+        <label class="provider-input-group" for="openai-compatible-preset">
+          <span class="provider-input-label">Preset</span>
+          <select id="openai-compatible-preset" class="provider-input">
+            <option value="lmstudio">LM Studio</option>
+            <option value="openai">OpenAI</option>
+            <option value="ollama">Ollama</option>
+            <option value="custom">Custom</option>
+          </select>
+        </label>
+
+        <p id="openai-compatible-preset-help" class="openrouter-connect-help">
+          LM Studio pre-fills the default local server endpoint at <code>http://localhost:1234/v1</code>.
+        </p>
+
+        <label class="provider-input-group" for="openai-compatible-base-url">
+          <span class="provider-input-label">Endpoint</span>
+          <input id="openai-compatible-base-url" class="provider-input" type="text" value="http://localhost:1234/v1" spellcheck="false" autocomplete="off" />
+        </label>
+
+        <label class="provider-input-group" for="openai-compatible-api-key">
+          <span class="provider-input-label">API key (optional)</span>
+          <input id="openai-compatible-api-key" class="provider-input" type="password" placeholder="Leave blank for local providers that do not require auth" spellcheck="false" autocomplete="off" />
+        </label>
+
+        <label class="openrouter-persist-toggle" for="openai-compatible-persist-checkbox">
+          <input id="openai-compatible-persist-checkbox" type="checkbox" />
+          <span>Save the OpenAI-compatible provider defaults to <code>~/.minicode/.env</code> after connecting.</span>
+        </label>
+
+        <p class="openrouter-connect-help">
+          When enabled, minicode will update <code>MODEL_PROVIDER</code> and <code>OPENAI_BASE_URL</code>, and it will also write <code>OPENAI_API_KEY</code> if you provide one. Nothing is written unless you check the box.
+        </p>
+
+        <p id="openai-compatible-connect-status" class="config-connect-status hidden"></p>
+      </div>
+
+      <div class="modal-footer">
+        <p class="settings-footnote">
+          This uses the same OpenAI-compatible runtime path minicode already uses for local and hosted providers.
+        </p>
+        <div class="settings-actions">
+          <button id="openai-compatible-connect-cancel" class="header-btn" type="button">Cancel</button>
+          <button id="openai-compatible-connect-continue" class="dropdown-action" type="button">Continue</button>
+        </div>
+      </div>
+    </section>
+  </div>
+
   <div id="file-preview-modal" class="modal hidden" aria-hidden="true">
     <div id="file-preview-backdrop" class="modal-backdrop"></div>
     <section class="modal-panel modal-panel-file-preview" role="dialog" aria-modal="true" aria-labelledby="file-preview-title">

package/dist/src/web/style.css

@@ -90,24 +90,51 @@ h1 {
 }
 
 #model-dropdown {
-  max-height: 320px;
+  width: min(420px, calc(100vw - 32px));
+  max-height: 360px;
+}
+
+#model-search {
+  width: 100%;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 4px;
+  color: var(--text);
+  font-family: var(--font-mono);
+  font-size: 12px;
+  padding: 6px 8px;
+}
+
+#model-search:focus {
+  outline: none;
+  border-color: var(--accent);
 }
 
 #model-list {
-  max-height: 280px;
+  max-height: 300px;
   overflow-y: auto;
 }
 
+.dropdown-search-section {
+  padding-bottom: 10px;
+}
+
 .model-item {
-  padding: 6px 8px;
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  width: 100%;
+  padding: 8px;
   border-radius: 4px;
   cursor: pointer;
+  border: none;
+  background: transparent;
+  text-align: left;
   font-size: 12px;
   transition: background 0.15s;
   color: var(--text);
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
+  font-family: var(--font-mono);
 }
 
 .model-item:hover {
@@ -115,8 +142,40 @@ h1 {
 }
 
 .model-item.active {
+  background: rgba(122, 162, 247, 0.12);
+  outline: 1px solid rgba(122, 162, 247, 0.35);
+}
+
+.model-item-body {
+  display: flex;
+  flex: 1;
+  flex-direction: column;
+  min-width: 0;
+}
+
+.model-item-name {
+  color: var(--text);
+  font-weight: 500;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.model-item-subtitle {
+  color: var(--text-dim);
+  font-size: 11px;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.model-item-badge {
   color: var(--accent);
+  font-size: 11px;
   font-weight: 600;
+  flex-shrink: 0;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
 }
 
 /* Session menu */
@@ -363,11 +422,17 @@ h1 {
   margin-bottom: 16px;
 }
 
-.config-overlay-spotlight {
+.config-overlay-shortcuts {
   display: flex;
   flex-direction: column;
   gap: 12px;
   margin-bottom: 16px;
+}
+
+.config-overlay-spotlight {
+  display: flex;
+  flex-direction: column;
+  gap: 12px;
   padding: 14px 16px;
   border-radius: 8px;
   border: 1px solid rgba(122, 162, 247, 0.35);
@@ -377,6 +442,13 @@ h1 {
   box-shadow: inset 0 1px 0 rgba(255, 255, 255, 0.03);
 }
 
+.config-overlay-spotlight-secondary {
+  border-color: rgba(158, 206, 106, 0.24);
+  background:
+    linear-gradient(135deg, rgba(158, 206, 106, 0.14), rgba(122, 162, 247, 0.06)),
+    var(--bg-surface);
+}
+
 .config-overlay-spotlight-copy {
   display: flex;
   flex-direction: column;
@@ -1188,6 +1260,31 @@ footer {
   flex-shrink: 0;
 }
 
+.settings-provider-shortcuts {
+  display: flex;
+  align-items: flex-start;
+  justify-content: space-between;
+  gap: 16px;
+  margin-bottom: 16px;
+  padding: 14px 16px;
+  border-radius: 10px;
+  border: 1px solid var(--border);
+  background: rgba(26, 27, 38, 0.72);
+}
+
+.settings-provider-shortcuts-copy {
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.settings-provider-shortcuts-actions {
+  display: flex;
+  gap: 8px;
+  flex-wrap: wrap;
+  justify-content: flex-end;
+}
+
 .openrouter-connect-body {
   padding: 20px;
   display: flex;
@@ -1240,11 +1337,48 @@ footer {
   color: var(--text);
 }
 
+.provider-input-group {
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+
+.provider-input-label {
+  color: var(--text);
+  font-size: 12px;
+  font-weight: 500;
+}
+
+.provider-input {
+  width: 100%;
+  background: var(--bg);
+  border: 1px solid var(--border);
+  border-radius: 6px;
+  color: var(--text);
+  font-family: var(--font-mono);
+  font-size: 12px;
+  padding: 9px 10px;
+}
+
+.provider-input:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
 @media (max-width: 760px) {
   .settings-session-banner {
     flex-direction: column;
     align-items: flex-start;
   }
+
+  .settings-provider-shortcuts {
+    flex-direction: column;
+  }
+
+  .settings-provider-shortcuts-actions {
+    width: 100%;
+    justify-content: flex-start;
+  }
 }
 
 .settings-list::-webkit-scrollbar,

package/dist/tests/agent.test.js

@@ -59,6 +59,21 @@ function createEchoTool() {
         execute: async (input) => `echo:${String(input.value)}`,
     };
 }
+function assertToolCallTranscriptIsComplete(messages) {
+    for (let i = 0; i < messages.length; i += 1) {
+        const message = messages[i];
+        if (message?.role !== "assistant" || !message.toolCalls?.length) {
+            continue;
+        }
+        const toolCalls = message.toolCalls;
+        for (let offset = 0; offset < toolCalls.length; offset += 1) {
+            const toolCall = toolCalls[offset];
+            const toolResult = messages[i + offset + 1];
+            assert.equal(toolResult?.role, "tool");
+            assert.equal(toolResult?.role === "tool" ? toolResult.toolCallId : undefined, toolCall.id);
+        }
+    }
+}
 test("agent executes tool calls and returns final assistant text", async () => {
     const responses = [
         {
@@ -96,6 +111,7 @@ test("agent stops on repeated identical tool calls", async () => {
     });
     const { text } = await agent.runTurn("Do something");
     assert.match(text, /repeated identical tool calls/);
+    assertToolCallTranscriptIsComplete(agent.getSession().getMessages());
 });
 test("agent tells the user how to continue when the turn call limit is reached", async () => {
     const config = createTestAgentConfig("/tmp");

package/dist/tests/config-integration.test.js

@@ -11,7 +11,7 @@ import { access, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { afterEach, describe, test } from "node:test";
-import { loadAgentConfig, resolveConfigEnv, getConfigSetupMessage, getConfigMissing, } from "../src/agent/config.js";
+import { loadAgentConfig, resolveConfigEnv, getConfigSetupMessage, getConfiguredProvider, getConfigMissing, } from "../src/agent/config.js";
 import { buildStructuredConfigPayload } from "../src/agent/editable-config.js";
 import { createRequestHandler } from "../src/serve/server.js";
 import { AgentBridge } from "../src/serve/agent-bridge.js";
@@ -637,6 +637,40 @@ describe("/api/status needsSetup", () => {
         assert.equal(body.model, "my-test-model");
         assert.equal(body.provider, "openai-compatible");
     });
+    test("status endpoint reports no configured provider for a fresh install using defaults", async () => {
+        const baseDir = await mkdtemp(path.join(os.tmpdir(), "minicode-integ-"));
+        tempDirs.push(baseDir);
+        const minicodeHome = path.join(baseDir, "new-home");
+        const config = {
+            ...createTestAgentConfig("/tmp"),
+            modelProvider: "openai-compatible",
+            model: "",
+            openAiBaseUrl: "http://localhost:1234/v1",
+        };
+        const bridge = new ConfigurableBridge(config);
+        const base = await startServer(bridge, { minicodeHome });
+        const res = await fetch(`${base}/api/status`);
+        const body = await res.json();
+        assert.equal(body.configuredProvider, null);
+        assert.equal(body.needsSetup, true);
+        assert.ok(body.missing.some((m) => m.includes("MODEL")));
+    });
+    test("status endpoint reports openai-compatible when localhost is explicitly configured", async () => {
+        const minicodeHome = await createTestHome({
+            config: {
+                modelProvider: "openai-compatible",
+                openAiBaseUrl: "http://localhost:1234/v1",
+            },
+        });
+        const config = await loadAgentConfig("/tmp", { minicodeHome });
+        const bridge = new ConfigurableBridge(config);
+        const base = await startServer(bridge, { minicodeHome });
+        const res = await fetch(`${base}/api/status`);
+        const body = await res.json();
+        assert.equal(body.configuredProvider, "openai-compatible");
+        assert.equal(body.needsSetup, true);
+        assert.ok(body.missing.some((m) => m.includes("MODEL")));
+    });
 });
 // ═══════════════════════════════════════════════════════════════════
 // /api/context — graceful degradation when agent not ready
@@ -823,3 +857,59 @@ describe("realistic user scenarios", () => {
         });
     });
 });
+describe("getConfiguredProvider", () => {
+    test("returns null for a fresh install using only fallback localhost defaults", async () => {
+        const base = await mkdtemp(path.join(os.tmpdir(), "minicode-integ-"));
+        tempDirs.push(base);
+        const minicodeHome = path.join(base, "new-home");
+        await withEnv({
+            MODEL: undefined,
+            MODEL_PROVIDER: undefined,
+            OPENAI_BASE_URL: undefined,
+            OPENAI_API_KEY: undefined,
+            OPENROUTER_API_KEY: undefined,
+            ANTHROPIC_API_KEY: undefined,
+        }, async () => {
+            const config = await loadAgentConfig("/tmp", { minicodeHome });
+            const resolvedEnv = await resolveConfigEnv({ minicodeHome });
+            assert.equal(getConfiguredProvider(config, resolvedEnv.values), null);
+        });
+    });
+    test("returns openrouter when OpenRouter is explicitly configured", async () => {
+        const home = await createTestHome({
+            config: {
+                modelProvider: "openai-compatible",
+                openAiBaseUrl: "https://openrouter.ai/api/v1",
+            },
+            dotenv: "OPENROUTER_API_KEY=sk-or-test-key\n",
+        });
+        await withEnv({
+            MODEL_PROVIDER: undefined,
+            OPENAI_BASE_URL: undefined,
+            OPENAI_API_KEY: undefined,
+            OPENROUTER_API_KEY: undefined,
+        }, async () => {
+            const config = await loadAgentConfig("/tmp", { minicodeHome: home });
+            const resolvedEnv = await resolveConfigEnv({ minicodeHome: home });
+            assert.equal(getConfiguredProvider(config, resolvedEnv.values), "openrouter");
+        });
+    });
+    test("returns openai-compatible when a local endpoint is explicitly configured", async () => {
+        const home = await createTestHome({
+            config: {
+                modelProvider: "openai-compatible",
+                openAiBaseUrl: "http://localhost:1234/v1",
+            },
+        });
+        await withEnv({
+            MODEL_PROVIDER: undefined,
+            OPENAI_BASE_URL: undefined,
+            OPENAI_API_KEY: undefined,
+            OPENROUTER_API_KEY: undefined,
+        }, async () => {
+            const config = await loadAgentConfig("/tmp", { minicodeHome: home });
+            const resolvedEnv = await resolveConfigEnv({ minicodeHome: home });
+            assert.equal(getConfiguredProvider(config, resolvedEnv.values), "openai-compatible");
+        });
+    });
+});

package/dist/tests/file-tools.test.js

@@ -91,6 +91,18 @@ test("run_command refresh removes deleted files from the index", async () => {
     await runTool.execute({ command: "rm src/util.ts" });
     assert.equal(index.getSymbol("add"), undefined, "deleted file should be removed from the index");
 });
+test("run_command times out commands that ignore SIGTERM", async () => {
+    const workspaceRoot = await createTempWorkspace();
+    const config = createTestAgentConfig(workspaceRoot);
+    config.commandTimeoutMs = 100;
+    const runTool = createRunCommandTool(config);
+    const start = Date.now();
+    const output = await runTool.execute({
+        command: `node -e 'process.on("SIGTERM", () => {}); setInterval(() => {}, 1000)'`,
+    });
+    assert.match(output, /timed_out: true/);
+    assert.ok(Date.now() - start < 5_000, "run_command should return after the timeout and kill grace period");
+});
 test("read_file supports negative offset and line limits", async () => {
     const workspaceRoot = await createTempWorkspace();
     const filePath = path.join(workspaceRoot, "lines.txt");

package/dist/tests/graph-onboarding.test.js

@@ -24,6 +24,7 @@ test('built HTML contains #cy graph container', () => {
     assert.ok(html.includes('id="cy"'), 'HTML should contain the #cy graph container');
     assert.ok(html.includes('id="graph-pane"'), 'HTML should contain the #graph-pane wrapper');
     assert.ok(html.includes('Search symbols or files...'), 'HTML should expose mixed symbol/file search');
+    assert.ok(html.includes('id="graph-refresh"'), 'HTML should expose a graph refresh button');
     assert.ok(html.includes('id="file-preview-modal"'), 'HTML should contain the file preview modal shell');
     assert.ok(html.includes('id="file-preview-code"'), 'HTML should contain the file preview code surface');
 });
@@ -67,6 +68,13 @@ test('built JS supports file search results and file-centered neighborhood rende
     assert.ok(js.includes('/api/file-source?path='), 'JS should fetch full file contents for the preview modal');
     assert.ok(js.includes('detail-file-link'), 'JS should wire the symbol detail filename into the preview modal');
 });
+test('built JS refreshes graph data manually and after mutating tool calls', () => {
+    const js = readFileSync(join(distWeb, 'app.js'), 'utf-8');
+    assert.ok(js.includes('/api/index/refresh'), 'manual graph refresh should call the backend index refresh endpoint');
+    assert.ok(js.includes('refreshGraphData'), 'JS should define a graph data refresh helper');
+    assert.ok(js.includes('scheduleGraphDataRefresh'), 'JS should debounce automatic graph refreshes after tool calls');
+    assert.ok(js.includes('"write_file"') && js.includes('"edit_file"') && js.includes('"run_command"'), 'mutating tools should trigger a graph data refresh so new symbols appear in search');
+});
 test('built CSS contains file preview modal sizing and link styling', () => {
     const css = readFileSync(join(distWeb, 'style.css'), 'utf-8');
     assert.ok(css.includes('.modal-panel-file-preview'), 'CSS should contain the file preview modal panel class');

package/dist/tests/model-client-openai.test.js

@@ -102,6 +102,47 @@ test("openai-compatible client sends correct app URL in HTTP-Referer header", as
     assert.equal(capturedHeaders["HTTP-Referer"], "https://minicode.seanholung.com", "HTTP-Referer should point to minicode.seanholung.com");
     assert.equal(capturedHeaders["X-Title"], "minicode");
 });
+test("openai-compatible client repairs missing tool results before sending", async () => {
+    let capturedBody = "";
+    const fetchImpl = async (_input, init) => {
+        capturedBody = String(init?.body ?? "");
+        return new Response(JSON.stringify({
+            choices: [
+                {
+                    finish_reason: "stop",
+                    message: { content: "ok", tool_calls: [] },
+                },
+            ],
+            usage: { prompt_tokens: 5, completion_tokens: 3 },
+        }), { status: 200, headers: { "content-type": "application/json" } });
+    };
+    const client = new OpenAICompatibleModelClient({
+        baseUrl: "http://localhost:1234/v1",
+        fetchImpl,
+    });
+    await client.chat({
+        model: "test-model",
+        system: "sys",
+        messages: [
+            { role: "user", content: "start" },
+            {
+                role: "assistant",
+                content: "checking",
+                toolCalls: [{ id: "call-missing", name: "read_file", input: { path: "src/index.ts" } }],
+            },
+            { role: "user", content: "continue" },
+        ],
+        tools: [],
+        maxTokens: 64,
+    });
+    const parsedBody = JSON.parse(capturedBody);
+    const messages = parsedBody.messages;
+    assert.equal(messages[2]?.role, "assistant");
+    assert.equal(messages[3]?.role, "tool");
+    assert.equal(messages[3]?.tool_call_id, "call-missing");
+    assert.match(String(messages[3]?.content), /Tool result unavailable/);
+    assert.equal(messages[4]?.role, "user");
+});
 test("createModelClient returns openai-compatible client", () => {
     const config = {
         ...createTestAgentConfig("/tmp"),

package/dist/tests/model-dropdown-ui.test.js

@@ -0,0 +1,23 @@
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { test } from "node:test";
+const distWeb = join(import.meta.dirname, "..", "dist", "src", "web");
+test("built HTML contains model search input", () => {
+    const html = readFileSync(join(distWeb, "index.html"), "utf8");
+    assert.ok(html.includes('id="model-search"'), "HTML should expose a dedicated model search input");
+    assert.ok(html.includes('placeholder="Search models..."'), "HTML should prompt users to search models");
+});
+test("built CSS contains searchable model dropdown styling", () => {
+    const css = readFileSync(join(distWeb, "style.css"), "utf8");
+    assert.ok(css.includes("#model-search"), "CSS should style the model search input");
+    assert.ok(css.includes(".model-item-body"), "CSS should support stacked model result content");
+    assert.ok(css.includes(".model-item-badge"), "CSS should style the active model badge");
+});
+test("built JS contains searchable model dropdown behavior", () => {
+    const js = readFileSync(join(distWeb, "app.js"), "utf8");
+    assert.ok(js.includes("filterModelsByQuery"), "JS should filter models by the dropdown query");
+    assert.ok(js.includes("focusModelSearchInput"), "JS should focus the search field when opening the dropdown");
+    assert.ok(js.includes("No matching models"), "JS should render an empty state for unmatched queries");
+    assert.ok(js.includes('modelSearchInput.addEventListener("input"'), "JS should update results as the user types");
+});

package/dist/tests/model-utils.test.js

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import { sortModelsAlphabetically } from "../src/model-utils.js";
+import { filterModelsByQuery, getModelDisplayName, sortModelsAlphabetically } from "../src/model-utils.js";
 test("sortModelsAlphabetically sorts by display name without mutating input", () => {
     const models = [
         { id: "zeta-2", name: "Zeta 2" },
@@ -20,3 +20,28 @@ test("sortModelsAlphabetically uses id as a stable tiebreaker", () => {
     const sorted = sortModelsAlphabetically(models);
     assert.deepEqual(sorted.map((model) => model.id), ["gpt-4.1-a", "gpt-4.1-b"]);
 });
+test("getModelDisplayName falls back to id and trims whitespace", () => {
+    assert.equal(getModelDisplayName({ id: "google/gemini-2.5-flash-preview", name: "  Gemini 2.5 Flash  " }), "Gemini 2.5 Flash");
+    assert.equal(getModelDisplayName({ id: "qwen/qwen3-coder" }), "qwen/qwen3-coder");
+});
+test("filterModelsByQuery matches on display name and id without mutating order", () => {
+    const models = [
+        { id: "z-ai/glm-4.5-air", name: "GLM 4.5 Air" },
+        { id: "google/gemini-2.5-flash-preview", name: "Gemini 2.5 Flash" },
+        { id: "openai/gpt-4.1-mini", name: "GPT-4.1 Mini" },
+    ];
+    const byName = filterModelsByQuery(models, "gemini flash");
+    const byId = filterModelsByQuery(models, "glm-4.5");
+    const blank = filterModelsByQuery(models, "   ");
+    assert.deepEqual(byName.map((model) => model.id), ["google/gemini-2.5-flash-preview"]);
+    assert.deepEqual(byId.map((model) => model.id), ["z-ai/glm-4.5-air"]);
+    assert.deepEqual(blank.map((model) => model.id), models.map((model) => model.id));
+});
+test("filterModelsByQuery returns all tokens match across name and id", () => {
+    const models = [
+        { id: "google/gemini-2.5-flash-preview", name: "Gemini Flash Preview" },
+        { id: "google/gemini-2.5-pro-preview", name: "Gemini Pro Preview" },
+    ];
+    const filtered = filterModelsByQuery(models, "google flash");
+    assert.deepEqual(filtered.map((model) => model.id), ["google/gemini-2.5-flash-preview"]);
+});