@miaws/miaw 1.18.5 → 1.18.6

package/test/server/httpapi-public-openapi.test.ts

@@ -1,319 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { OpenApi } from "effect/unstable/httpapi"
-import { PublicApi } from "../../src/server/routes/instance/httpapi/public"
-
-type Method = "get" | "post" | "put" | "delete" | "patch"
-type OpenApiSchema = {
-  readonly $ref?: string
-  readonly anyOf?: ReadonlyArray<OpenApiSchema>
-  readonly type?: string
-  readonly enum?: readonly unknown[]
-  readonly properties?: Record<string, OpenApiSchema>
-  readonly required?: readonly string[]
-}
-type OpenApiResponse = {
-  readonly description?: string
-  readonly content?: Record<string, { readonly schema?: OpenApiSchema }>
-}
-type OpenApiOperation = {
-  readonly parameters?: ReadonlyArray<{
-    readonly name: string
-    readonly in: string
-    readonly required?: boolean
-    readonly schema?: { readonly type?: string }
-  }>
-  readonly responses?: Record<string, OpenApiResponse>
-  readonly requestBody?: { readonly required?: boolean }
-  readonly security?: unknown
-}
-type OpenApiPathItem = Partial<Record<Method, OpenApiOperation>>
-type OpenApiSpec = {
-  readonly paths: Record<string, OpenApiPathItem>
-  readonly components: { readonly schemas: Record<string, OpenApiSchema> }
-}
-
-const methods = ["get", "post", "put", "delete", "patch"] as const
-
-const allowedV2BuiltInEndpointErrors: string[] = []
-
-function v2Operations(spec: OpenApiSpec) {
-  return Object.entries(spec.paths).flatMap(([path, item]) =>
-    path.startsWith("/api/")
-      ? methods.flatMap((method) => {
-          const operation = item[method]
-          return operation ? [{ method, path, operation }] : []
-        })
-      : [],
-  )
-}
-
-function responseRef(response: OpenApiResponse | undefined) {
-  return response?.content?.["application/json"]?.schema?.$ref
-}
-
-function componentName(ref: string) {
-  return ref.replace("#/components/schemas/", "")
-}
-
-function componentNames(response: OpenApiResponse | undefined) {
-  const schema = response?.content?.["application/json"]?.schema
-  if (!schema) return []
-  return [
-    ...new Set([schema, ...(schema.anyOf ?? [])].flatMap((item) => (item.$ref ? [componentName(item.$ref)] : []))),
-  ]
-}
-
-function isBuiltInEndpointError(name: string) {
-  return name.startsWith("EffectHttpApiError") || name.startsWith("effect_HttpApiError_")
-}
-
-describe("PublicApi OpenAPI v2 errors", () => {
-  test("documents nested legacy global sync events", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-    const schema = spec.components.schemas.SyncEventSessionCreated
-
-    expect(schema?.required).toEqual(["type", "id", "syncEvent"])
-    expect(schema?.properties?.type?.enum).toEqual(["sync"])
-    expect(schema?.properties?.syncEvent).toMatchObject({
-      required: ["type", "id", "seq", "aggregateID", "data"],
-      properties: {
-        type: { enum: ["session.created.1"] },
-        id: { type: "string" },
-        seq: { type: "number" },
-        aggregateID: { type: "string" },
-      },
-    })
-  })
-
-  test("preserves /api auth responses", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const route of v2Operations(spec)) {
-      expect(route.operation.responses?.["401"], `${route.method.toUpperCase()} ${route.path}`).toBeDefined()
-      expect(route.operation.security, `${route.method.toUpperCase()} ${route.path}`).toEqual([])
-    }
-  })
-
-  test("documents references separately from filesystem routes", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const path of ["/api/fs/read/*", "/api/fs/list"]) {
-      expect(spec.paths[path]?.get?.parameters, path).not.toContainEqual(expect.objectContaining({ name: "reference" }))
-    }
-    expect(spec.paths["/api/reference"]?.get).toBeDefined()
-  })
-
-  test("preserves required request bodies for v2 mutations", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const path of [
-      "/api/session/{sessionID}/prompt",
-      "/api/session/{sessionID}/permission/{requestID}/reply",
-      "/api/session/{sessionID}/question/{requestID}/reply",
-    ]) {
-      expect(spec.paths[path]?.post?.requestBody?.required, path).toBe(true)
-    }
-  })
-
-  test("documents integration discovery and connection routes", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const [method, path] of [
-      ["get", "/api/integration"],
-      ["get", "/api/integration/{integrationID}"],
-      ["post", "/api/integration/{integrationID}/connect/key"],
-      ["post", "/api/integration/{integrationID}/connect/oauth"],
-      ["get", "/api/integration/attempt/{attemptID}"],
-      ["post", "/api/integration/attempt/{attemptID}/complete"],
-      ["delete", "/api/integration/attempt/{attemptID}"],
-      ["delete", "/api/credential/{credentialID}"],
-      ["patch", "/api/credential/{credentialID}"],
-    ] as const) {
-      expect(spec.paths[path]?.[method], `${method.toUpperCase()} ${path}`).toBeDefined()
-    }
-
-    for (const path of [
-      "/api/integration/{integrationID}/connect/key",
-      "/api/integration/{integrationID}/connect/oauth",
-      "/api/integration/attempt/{attemptID}/complete",
-    ]) {
-      expect(spec.paths[path]?.post?.requestBody?.required, path).toBe(true)
-    }
-  })
-
-  test("does not rewrite /api endpoint errors to legacy error components", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-    const refs = v2Operations(spec)
-      .flatMap((route) =>
-        Object.entries(route.operation.responses ?? {}).flatMap(([status, response]) => {
-          const ref = responseRef(response)
-          return ref ? [`${route.method.toUpperCase()} ${route.path} ${status} ${componentName(ref)}`] : []
-        }),
-      )
-      .filter((entry) => entry.endsWith(" BadRequestError") || entry.endsWith(" NotFoundError"))
-
-    expect(refs).toEqual([])
-  })
-
-  test("new /api endpoint errors cannot use built-in components without an explicit allowlist", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-    const builtInEndpointErrors = v2Operations(spec)
-      .flatMap((route) =>
-        Object.entries(route.operation.responses ?? {}).flatMap(([status, response]) => {
-          if (status === "401") return []
-          const ref = responseRef(response)
-          if (!ref) return []
-          const name = componentName(ref)
-          return isBuiltInEndpointError(name) ? [`${route.method.toUpperCase()} ${route.path} ${status} ${name}`] : []
-        }),
-      )
-      .sort()
-
-    expect(builtInEndpointErrors).toEqual(allowedV2BuiltInEndpointErrors)
-  })
-
-  test("documents v2 provider and model catalog errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    expect(componentName(responseRef(spec.paths["/api/provider"]?.get?.responses?.["503"]) ?? "")).toBe(
-      "ServiceUnavailableError",
-    )
-    expect(componentName(responseRef(spec.paths["/api/model"]?.get?.responses?.["503"]) ?? "")).toBe(
-      "ServiceUnavailableError",
-    )
-    expect(componentName(responseRef(spec.paths["/api/provider/{providerID}"]?.get?.responses?.["404"]) ?? "")).toBe(
-      "ProviderNotFoundError",
-    )
-    expect(componentName(responseRef(spec.paths["/api/provider/{providerID}"]?.get?.responses?.["503"]) ?? "")).toBe(
-      "ServiceUnavailableError",
-    )
-  })
-
-  test("documents v2 session not-found errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const route of [
-      ["post", "/api/session/{sessionID}/prompt"],
-      ["post", "/api/session/{sessionID}/compact"],
-      ["post", "/api/session/{sessionID}/wait"],
-      ["get", "/api/session/{sessionID}/context"],
-      ["get", "/api/session/{sessionID}/message"],
-    ] as const) {
-      expect(componentNames(spec.paths[route[1]]?.[route[0]]?.responses?.["404"])).toContain("SessionNotFoundError")
-    }
-  })
-
-  test("documents v2 unfinished session mutation errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const route of [
-      ["post", "/api/session/{sessionID}/compact"],
-      ["post", "/api/session/{sessionID}/wait"],
-    ] as const) {
-      expect(componentName(responseRef(spec.paths[route[1]]?.[route[0]]?.responses?.["503"]) ?? "")).toBe(
-        "ServiceUnavailableError",
-      )
-    }
-  })
-
-  test("documents v2 session read data errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const route of [
-      ["get", "/api/session/{sessionID}/context"],
-      ["get", "/api/session/{sessionID}/message"],
-    ] as const) {
-      expect(componentName(responseRef(spec.paths[route[1]]?.[route[0]]?.responses?.["500"]) ?? "")).toMatch(
-        /^UnknownError\d*$/,
-      )
-    }
-  })
-
-  test("documents session busy errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const route of [
-      ["post", "/session/{sessionID}/shell"],
-      ["post", "/session/{sessionID}/revert"],
-      ["post", "/session/{sessionID}/unrevert"],
-      ["delete", "/session/{sessionID}/message/{messageID}"],
-    ] as const) {
-      expect(componentName(responseRef(spec.paths[route[1]]?.[route[0]]?.responses?.["409"]) ?? "")).toBe(
-        "SessionBusyError",
-      )
-    }
-  })
-
-  test("documents permission and question not-found errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    expect(
-      componentName(responseRef(spec.paths["/permission/{requestID}/reply"]?.post?.responses?.["404"]) ?? ""),
-    ).toBe("PermissionNotFoundError")
-    for (const route of [
-      ["post", "/question/{requestID}/reply"],
-      ["post", "/question/{requestID}/reject"],
-    ] as const) {
-      expect(componentName(responseRef(spec.paths[route[1]]?.[route[0]]?.responses?.["404"]) ?? "")).toBe(
-        "QuestionNotFoundError",
-      )
-    }
-    for (const route of [
-      ["post", "/api/session/{sessionID}/question/{requestID}/reply"],
-      ["post", "/api/session/{sessionID}/question/{requestID}/reject"],
-    ] as const) {
-      expect(componentNames(spec.paths[route[1]]?.[route[0]]?.responses?.["404"])).toEqual([
-        "QuestionNotFoundError",
-        "SessionNotFoundError",
-      ])
-    }
-  })
-
-  test("documents MCP server not-found errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const route of [
-      ["post", "/mcp/{name}/auth"],
-      ["post", "/mcp/{name}/auth/authenticate"],
-      ["post", "/mcp/{name}/auth/callback"],
-      ["delete", "/mcp/{name}/auth"],
-      ["post", "/mcp/{name}/connect"],
-      ["post", "/mcp/{name}/disconnect"],
-    ] as const) {
-      expect(componentName(responseRef(spec.paths[route[1]]?.[route[0]]?.responses?.["404"]) ?? "")).toBe(
-        "McpServerNotFoundError",
-      )
-    }
-  })
-
-  test("documents PTY resource and ticket errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    for (const route of [
-      ["get", "/pty/{ptyID}"],
-      ["put", "/pty/{ptyID}"],
-      ["delete", "/pty/{ptyID}"],
-      ["post", "/pty/{ptyID}/connect-token"],
-    ] as const) {
-      expect(componentName(responseRef(spec.paths[route[1]]?.[route[0]]?.responses?.["404"]) ?? "")).toBe(
-        "PtyNotFoundError",
-      )
-    }
-    expect(componentName(responseRef(spec.paths["/pty/{ptyID}/connect-token"]?.post?.responses?.["403"]) ?? "")).toBe(
-      "PtyForbiddenError",
-    )
-    expect(
-      spec.paths["/pty/{ptyID}/connect"]?.get?.parameters
-        ?.filter((parameter) => parameter.in === "query")
-        .map((parameter) => parameter.name),
-    ).toEqual(["directory", "workspace", "cursor", "ticket"])
-  })
-
-  test("documents project not-found errors", () => {
-    const spec = OpenApi.fromApi(PublicApi) as OpenApiSpec
-
-    expect(componentName(responseRef(spec.paths["/project/{projectID}"]?.patch?.responses?.["404"]) ?? "")).toBe(
-      "ProjectNotFoundError",
-    )
-  })
-})

package/test/server/httpapi-query-schema-drift.test.ts

@@ -1,330 +0,0 @@
-import { afterEach, describe, expect } from "bun:test"
-import { Effect, Schema } from "effect"
-import { OpenApi } from "effect/unstable/httpapi"
-import { Flag } from "@miaw/core/flag/flag"
-import { Server } from "../../src/server/server"
-import { SessionID } from "../../src/session/schema"
-import { PublicApi } from "../../src/server/routes/instance/httpapi/public"
-import {
-  FilePaths,
-  FileQuery,
-  FindFileQuery,
-  FindTextQuery,
-} from "../../src/server/routes/instance/httpapi/groups/file"
-import {
-  ExperimentalPaths,
-  SessionListQuery as ExperimentalSessionListQuery,
-  ToolListQuery,
-} from "../../src/server/routes/instance/httpapi/groups/experimental"
-import { InstancePaths, VcsDiffQuery } from "../../src/server/routes/instance/httpapi/groups/instance"
-import { WorkspacePaths } from "../../src/server/routes/instance/httpapi/groups/workspace"
-import {
-  ListQuery as SessionListQuery,
-  MessagesQuery,
-  SessionPaths,
-} from "../../src/server/routes/instance/httpapi/groups/session"
-import { PtyPaths } from "../../src/server/routes/instance/httpapi/groups/pty"
-import { SessionMessagesQuery } from "@miaw/server/groups/message"
-import { QueryBoolean, QueryBooleanOpenApi } from "../../src/server/routes/instance/httpapi/groups/query"
-import { resetDatabase } from "../fixture/db"
-import { disposeAllInstances, tmpdir } from "../fixture/fixture"
-import { it } from "../lib/effect"
-
-const originalWorkspaces = Flag.MIAW_EXPERIMENTAL_WORKSPACES
-
-type Method = "get" | "post" | "put" | "delete" | "patch"
-type QuerySchema = { readonly fields: Record<string, unknown> }
-type OpenApiSchema = {
-  readonly anyOf?: readonly OpenApiSchema[]
-  readonly enum?: readonly string[]
-  readonly maximum?: number
-  readonly minimum?: number
-  readonly pattern?: string
-  readonly type?: string
-}
-type OpenApiParameter = { readonly name: string; readonly in: string; readonly schema?: OpenApiSchema }
-type OpenApiOperation = { readonly parameters?: readonly OpenApiParameter[] }
-
-const openApiDriftRoutes = [
-  { method: "get", path: SessionPaths.list, query: SessionListQuery },
-  { method: "get", path: SessionPaths.messages, query: MessagesQuery },
-  { method: "get", path: FilePaths.findFile, query: FindFileQuery },
-  { method: "get", path: FilePaths.findText, query: FindTextQuery },
-  { method: "get", path: FilePaths.list, query: FileQuery },
-  { method: "get", path: ExperimentalPaths.session, query: ExperimentalSessionListQuery },
-  { method: "get", path: ExperimentalPaths.tool, query: ToolListQuery },
-  { method: "get", path: InstancePaths.vcsDiff, query: VcsDiffQuery },
-  { method: "get", path: "/api/session/:sessionID/message", query: SessionMessagesQuery },
-] satisfies Array<{ method: Method; path: string; query: QuerySchema }>
-
-const numericSdkQueryParams = [
-  { method: "get", path: ExperimentalPaths.session, name: "start", schema: { type: "number" } },
-  { method: "get", path: ExperimentalPaths.session, name: "cursor", schema: { type: "number" } },
-  { method: "get", path: ExperimentalPaths.session, name: "limit", schema: { type: "number" } },
-  { method: "get", path: FilePaths.findFile, name: "limit", schema: { type: "integer", minimum: 1, maximum: 200 } },
-  { method: "get", path: SessionPaths.list, name: "start", schema: { type: "number" } },
-  { method: "get", path: SessionPaths.list, name: "limit", schema: { type: "number" } },
-  {
-    method: "get",
-    path: SessionPaths.messages,
-    name: "limit",
-    schema: { type: "integer", minimum: 0, maximum: Number.MAX_SAFE_INTEGER },
-  },
-  { method: "get", path: "/api/session/:sessionID/message", name: "limit", schema: { type: "number" } },
-] satisfies Array<{ method: Method; path: string; name: string; schema: OpenApiSchema }>
-
-const booleanSdkQueryParams = [
-  { method: "get", path: ExperimentalPaths.session, name: "roots" },
-  { method: "get", path: ExperimentalPaths.session, name: "archived" },
-  { method: "get", path: SessionPaths.list, name: "roots" },
-] satisfies Array<{ method: Method; path: string; name: string }>
-
-const queryParamPatterns = [
-  { method: "get", path: SessionPaths.diff, name: "messageID", pattern: "^msg" },
-] satisfies Array<{ method: Method; path: string; name: string; pattern: string }>
-
-const pathParamPatterns = [
-  { method: "get", path: SessionPaths.get, name: "sessionID", pattern: "^ses" },
-  { method: "get", path: SessionPaths.message, name: "messageID", pattern: "^msg" },
-  { method: "patch", path: SessionPaths.updatePart, name: "partID", pattern: "^prt" },
-  { method: "post", path: SessionPaths.permissions, name: "permissionID", pattern: "^per" },
-  { method: "post", path: "/permission/:requestID/reply", name: "requestID", pattern: "^per" },
-  { method: "post", path: "/question/:requestID/reply", name: "requestID", pattern: "^que" },
-  { method: "put", path: PtyPaths.update, name: "ptyID", pattern: "^pty" },
-  { method: "delete", path: WorkspacePaths.remove, name: "id", pattern: "^wrk" },
-] satisfies Array<{ method: Method; path: string; name: string; pattern: string }>
-
-function app() {
-  return Server.Default().app
-}
-
-function request(url: string, init?: RequestInit) {
-  return Effect.promise(async () => app().request(url, init))
-}
-
-function withTmp<A, E, R>(
-  options: Parameters<typeof tmpdir>[0],
-  fn: (tmp: Awaited<ReturnType<typeof tmpdir>>) => Effect.Effect<A, E, R>,
-) {
-  return Effect.acquireRelease(
-    Effect.promise(() => tmpdir(options)),
-    (tmp) => Effect.promise(() => tmp[Symbol.asyncDispose]()),
-  ).pipe(Effect.flatMap(fn))
-}
-
-function openApiPath(path: string) {
-  return path.replace(/:([A-Za-z0-9_]+)/g, "{$1}")
-}
-
-function queryParameters(operation: OpenApiOperation | undefined) {
-  return (operation?.parameters ?? []).filter((param) => param.in === "query").map((param) => param.name)
-}
-
-function queryParameter(operation: OpenApiOperation | undefined, name: string) {
-  return (operation?.parameters ?? []).find((param) => param.in === "query" && param.name === name)
-}
-
-function pathParameter(operation: OpenApiOperation | undefined, name: string) {
-  return (operation?.parameters ?? []).find((param) => param.in === "path" && param.name === name)
-}
-
-function assertAdvertisedQueryParamsAreRuntimeFields(input: {
-  readonly method: Method
-  readonly operation: OpenApiOperation | undefined
-  readonly path: string
-  readonly query: QuerySchema
-}) {
-  const runtimeFields = new Set(Object.keys(input.query.fields))
-  const advertisedOnly = queryParameters(input.operation).filter((name) => !runtimeFields.has(name))
-
-  expect(
-    advertisedOnly,
-    `${input.method.toUpperCase()} ${input.path} advertises query params not accepted by runtime schema`,
-  ).toEqual([])
-}
-
-afterEach(async () => {
-  Flag.MIAW_EXPERIMENTAL_WORKSPACES = originalWorkspaces
-  await disposeAllInstances()
-  await resetDatabase()
-})
-
-// Regression for the "OpenAPI advertises ?directory&workspace, runtime
-// rejects them" drift class. Each affected route must accept both params
-// without 400.
-describe("httpapi query schema drift", () => {
-  const routingParams = (dir: string) =>
-    `directory=${encodeURIComponent(dir)}&workspace=${encodeURIComponent("ws_test")}`
-
-  const expectNotSchemaRejection = (status: number, url: string) => {
-    expect(status, `route ${url} 400'd, query schema is missing routing fields`).not.toBe(400)
-  }
-
-  it.effect(
-    "boolean query schema accepts only true and false strings",
-    Effect.sync(() => {
-      const decode = Schema.decodeUnknownSync(QueryBoolean)
-      const encode = Schema.encodeUnknownSync(QueryBoolean)
-
-      expect(decode("true")).toBe(true)
-      expect(decode("false")).toBe(false)
-      expect(encode(true)).toBe("true")
-      expect(encode(false)).toBe("false")
-
-      for (const input of ["1", "yes", "True", "", true, false]) {
-        expect(() => decode(input)).toThrow()
-      }
-    }),
-  )
-
-  it.effect(
-    "OpenAPI query params are declared by runtime query schemas",
-    Effect.sync(() => {
-      const spec = OpenApi.fromApi(PublicApi)
-      for (const route of openApiDriftRoutes) {
-        assertAdvertisedQueryParamsAreRuntimeFields({
-          ...route,
-          operation: spec.paths[openApiPath(route.path)]?.[route.method],
-        })
-      }
-    }),
-  )
-
-  it.effect(
-    "OpenAPI query and path schemas preserve compatibility metadata",
-    Effect.sync(() => {
-      const spec = OpenApi.fromApi(PublicApi)
-      for (const expected of numericSdkQueryParams) {
-        expect(
-          queryParameter(spec.paths[openApiPath(expected.path)]?.[expected.method], expected.name)?.schema,
-          `${expected.method.toUpperCase()} ${expected.path} ${expected.name}`,
-        ).toEqual(expected.schema)
-      }
-      for (const expected of booleanSdkQueryParams) {
-        expect(
-          queryParameter(spec.paths[openApiPath(expected.path)]?.[expected.method], expected.name)?.schema,
-          `${expected.method.toUpperCase()} ${expected.path} ${expected.name}`,
-        ).toEqual(QueryBooleanOpenApi)
-      }
-      for (const expected of queryParamPatterns) {
-        expect(
-          queryParameter(spec.paths[openApiPath(expected.path)]?.[expected.method], expected.name)?.schema,
-          `${expected.method.toUpperCase()} ${expected.path} ${expected.name}`,
-        ).toEqual({ type: "string", pattern: expected.pattern })
-      }
-      for (const expected of pathParamPatterns) {
-        expect(
-          pathParameter(spec.paths[openApiPath(expected.path)]?.[expected.method], expected.name)?.schema,
-          `${expected.method.toUpperCase()} ${expected.path} ${expected.name}`,
-        ).toEqual({ type: "string", pattern: expected.pattern })
-      }
-    }),
-  )
-
-  it.effect(
-    "drift assertion catches spec-only workspace query params",
-    Effect.sync(() => {
-      expect(() =>
-        assertAdvertisedQueryParamsAreRuntimeFields({
-          method: "get",
-          operation: {
-            parameters: [
-              { name: "directory", in: "query" },
-              { name: "workspace", in: "query" },
-            ],
-          },
-          path: "/fixture",
-          query: Schema.Struct({}),
-        }),
-      ).toThrow("advertises query params not accepted by runtime schema")
-    }),
-  )
-
-  it.live(
-    "session list accepts directory and workspace",
-    withTmp({ config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const url = `/session?${routingParams(tmp.path)}`
-        const response = yield* request(url)
-        expectNotSchemaRejection(response.status, url)
-      }),
-    ),
-  )
-
-  it.live(
-    "session messages accepts directory and workspace",
-    withTmp({ config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const url = `/session/${SessionID.descending()}/message?limit=80&${routingParams(tmp.path)}`
-        const response = yield* request(url)
-        expectNotSchemaRejection(response.status, url)
-      }),
-    ),
-  )
-
-  it.live(
-    "file find/file accepts directory and workspace",
-    withTmp({ config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const url = `/find/file?query=foo&${routingParams(tmp.path)}`
-        const response = yield* request(url)
-        expectNotSchemaRejection(response.status, url)
-      }),
-    ),
-  )
-
-  it.live(
-    "file find/text accepts directory and workspace",
-    withTmp({ config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const url = `/find?pattern=foo&${routingParams(tmp.path)}`
-        const response = yield* request(url)
-        expectNotSchemaRejection(response.status, url)
-      }),
-    ),
-  )
-
-  it.live(
-    "file read accepts directory and workspace",
-    withTmp({ config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const url = `/file?path=foo&${routingParams(tmp.path)}`
-        const response = yield* request(url)
-        expectNotSchemaRejection(response.status, url)
-      }),
-    ),
-  )
-
-  it.live(
-    "experimental session list accepts directory and workspace",
-    withTmp({ config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const url = `/experimental/session?${routingParams(tmp.path)}`
-        const response = yield* request(url)
-        expectNotSchemaRejection(response.status, url)
-      }),
-    ),
-  )
-
-  it.live(
-    "experimental tool list accepts directory and workspace",
-    withTmp({ config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const url = `/experimental/tool?provider=anthropic&model=claude&${routingParams(tmp.path)}`
-        const response = yield* request(url)
-        expectNotSchemaRejection(response.status, url)
-      }),
-    ),
-  )
-
-  it.live(
-    "vcs diff accepts directory and workspace",
-    withTmp({ config: { formatter: false, lsp: false } }, (tmp) =>
-      Effect.gen(function* () {
-        const url = `/vcs/diff?mode=working&${routingParams(tmp.path)}`
-        const response = yield* request(url)
-        expectNotSchemaRejection(response.status, url)
-      }),
-    ),
-  )
-})