chore: generate

packages/app/src/components/directory-picker-domain.test.ts

@@ -139,6 +139,7 @@ test("resolves directory autocomplete from the current browser root", async () =
           directories.push(input.location?.directory ?? "")
           return Promise.resolve({ data: [] })
         },
+        list: () => Promise.resolve({ data: [] }),
       },
     },
   } as unknown as Parameters<typeof createDirectorySearch>[0]["sdk"]
@@ -152,6 +153,67 @@ test("resolves directory autocomplete from the current browser root", async () =
   expect(directories).toEqual(["/repo", "/repo/src"])
 })
 
+test("keeps indexed directory results for servers that support empty search", async () => {
+  const sdk = {
+    api: {
+      file: {
+        find: () => Promise.resolve({ data: [{ path: "projects/", type: "directory" }] }),
+        list: () => Promise.reject(new Error("listing should not run when search returns results")),
+      },
+    },
+  } as unknown as Parameters<typeof createDirectorySearch>[0]["sdk"]
+  const search = createDirectorySearch({ sdk, home: () => "/home/luke", base: () => "/home/luke" })
+
+  expect(await search("")).toEqual(["/home/luke/projects"])
+})
+
+test("lists the default directory when empty search is unsupported", async () => {
+  const calls: string[] = []
+  const directories = Array.from({ length: 60 }, (_, index) => ({
+    path: `project-${index}/`,
+    type: "directory" as const,
+  }))
+  const sdk = {
+    api: {
+      file: {
+        find: () => Promise.resolve({ data: [] }),
+        list: (input: { location?: { directory?: string } }) => {
+          calls.push(input.location?.directory ?? "")
+          return Promise.resolve({
+            data: [...directories, { path: "README.md", type: "file" }],
+          })
+        },
+      },
+    },
+  } as unknown as Parameters<typeof createDirectorySearch>[0]["sdk"]
+  const search = createDirectorySearch({ sdk, home: () => "/home/luke", base: () => "/home/luke" })
+
+  const results = await search("")
+  expect(results).toHaveLength(60)
+  expect(results.at(-1)).toBe("/home/luke/project-59")
+  expect(calls).toEqual(["/home/luke"])
+})
+
+test("matches the default directory listing when typed search is unsupported", async () => {
+  const sdk = {
+    api: {
+      file: {
+        find: () => Promise.resolve({ data: [] }),
+        list: () =>
+          Promise.resolve({
+            data: [
+              { path: "Documents/", type: "directory" },
+              { path: "Downloads/", type: "directory" },
+            ],
+          }),
+      },
+    },
+  } as unknown as Parameters<typeof createDirectorySearch>[0]["sdk"]
+  const search = createDirectorySearch({ sdk, home: () => "/home/luke", base: () => "/home/luke" })
+
+  expect(await search("documents")).toEqual(["/home/luke/Documents"])
+})
+
 test("searches from an absolute root without a default base", async () => {
   const directories: string[] = []
   const sdk = {

packages/app/src/components/directory-picker-domain.ts

@@ -379,7 +379,14 @@ export function createDirectorySearch(args: { sdk: ServerSDK; base: () => string
         .then((result) => result.data.map((entry) => entry.path))
         .catch(() => [])
       if (!active()) return []
-      return results.map((path) => joinPickerPath(input.directory, path)).slice(0, 50)
+      if (results.length) {
+        return results.map((path) => joinPickerPath(input.directory, path)).slice(0, 50)
+      }
+      const fallback = query
+        ? await match(input.directory, query, 50)
+        : (await directories(input.directory)).map((item) => item.absolute)
+      if (!active()) return []
+      return fallback
     }
     const segments = query.replace(/^\/+/, "").split("/")
     const head = segments.slice(0, -1).filter((part) => part && part !== ".")

packages/core/test/session-runner-message.test.ts

@@ -498,60 +498,4 @@ Recent work
       },
     ])
   })
-
-  test("does not lower duplicate tool call IDs from interrupted history", () => {
-    const messages = toLLMMessages(
-      [
-        SessionMessage.Assistant.make({
-          id: id("duplicate-tool-call"),
-          type: "assistant",
-          agent: "build",
-          model: { id: ModelV2.ID.make("model"), providerID: ProviderV2.ID.make("provider") },
-          content: [
-            SessionMessage.AssistantTool.make({
-              type: "tool",
-              id: "call_1",
-              name: "read",
-              state: SessionMessage.ToolStateCompleted.make({
-                status: "completed",
-                input: { path: "README.md" },
-                content: [{ type: "text", text: "done" }],
-                structured: {},
-              }),
-              time: { created, completed: created },
-            }),
-            SessionMessage.AssistantTool.make({
-              type: "tool",
-              id: "call_1",
-              name: "unknown",
-              state: SessionMessage.ToolStateError.make({
-                status: "error",
-                input: {},
-                content: [],
-                structured: {},
-                error: { type: "unknown", message: "Tool execution interrupted" },
-              }),
-              time: { created, completed: created },
-            }),
-          ],
-          time: { created, completed: created },
-        }),
-      ],
-      model,
-    )
-
-    const calls = messages.flatMap((message) =>
-      message.content.filter((part) => part.type === "tool-call" && part.id === "call_1"),
-    )
-    expect(calls).toEqual([
-      {
-        type: "tool-call",
-        id: "call_1",
-        name: "read",
-        input: { path: "README.md" },
-        providerExecuted: undefined,
-        providerMetadata: undefined,
-      },
-    ])
-  })
 })