saeeol 1.2.5 → 1.2.7

package/test/provider/models.test.ts

@@ -1,261 +0,0 @@
-import { describe, expect, beforeAll, beforeEach, afterAll } from "bun:test"
-import { Effect, Layer, Ref } from "effect"
-import { HttpClient, HttpClientResponse } from "effect/unstable/http"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { Flag } from "@saeeol/core/flag/flag"
-import { Global } from "@saeeol/core/global"
-import { ModelsDev } from "../../src/provider/models"
-import { it } from "../lib/effect"
-import { rm, writeFile, utimes, mkdir } from "fs/promises"
-import path from "path"
-
-// test/preload.ts pins SAEEOL_MODELS_PATH to a fixture so other tests can
-// resolve providers without network. These tests need to drive the on-disk
-// cache themselves and silence the eager refresh fork. Save/restore around
-// the suite — never leak the mutation to subsequent test files in the same
-// bun process.
-const ORIGINAL_MODELS_PATH = Flag.SAEEOL_MODELS_PATH
-const ORIGINAL_DISABLE_FETCH = Flag.SAEEOL_DISABLE_MODELS_FETCH
-beforeAll(() => {
-  Flag.SAEEOL_MODELS_PATH = undefined
-  Flag.SAEEOL_DISABLE_MODELS_FETCH = true
-})
-afterAll(() => {
-  Flag.SAEEOL_MODELS_PATH = ORIGINAL_MODELS_PATH
-  Flag.SAEEOL_DISABLE_MODELS_FETCH = ORIGINAL_DISABLE_FETCH
-})
-
-const cacheFile = path.join(Global.Path.cache, "models.json")
-
-const fixture: Record<string, ModelsDev.Provider> = {
-  acme: {
-    id: "acme",
-    name: "Acme",
-    env: ["ACME_API_KEY"],
-    models: {
-      "acme-1": {
-        id: "acme-1",
-        name: "Acme One",
-        release_date: "2026-01-01",
-        attachment: false,
-        reasoning: false,
-        temperature: true,
-        tool_call: true,
-        limit: { context: 128000, output: 8192 },
-      },
-    },
-  },
-}
-
-const fixture2: Record<string, ModelsDev.Provider> = {
-  beta: {
-    id: "beta",
-    name: "Beta",
-    env: ["BETA_API_KEY"],
-    models: {
-      "beta-1": {
-        id: "beta-1",
-        name: "Beta One",
-        release_date: "2026-02-01",
-        attachment: false,
-        reasoning: true,
-        temperature: false,
-        tool_call: false,
-        limit: { context: 64000, output: 4096 },
-      },
-    },
-  },
-}
-
-interface MockState {
-  body: string
-  status: number
-  calls: Array<{ url: string }>
-}
-
-const makeMockClient = (state: Ref.Ref<MockState>) =>
-  HttpClient.make((request) =>
-    Effect.gen(function* () {
-      yield* Ref.update(state, (s) => ({ ...s, calls: [...s.calls, { url: request.url }] }))
-      const s = yield* Ref.get(state)
-      return HttpClientResponse.fromWeb(request, new Response(s.body, { status: s.status }))
-    }),
-  )
-
-const buildLayer = (state: Ref.Ref<MockState>) =>
-  // Layer.fresh is required: ModelsDev.layer is a module-level Layer constant,
-  // and Effect.provide uses a process-global MemoMap by default — without fresh,
-  // every test would reuse the cachedInvalidateWithTTL state from the first run.
-  Layer.fresh(ModelsDev.layer).pipe(
-    Layer.provide(Layer.succeed(HttpClient.HttpClient, makeMockClient(state))),
-    Layer.provide(AppFileSystem.defaultLayer),
-  )
-
-const writeCache = (data: object, mtimeMs?: number) =>
-  Effect.promise(async () => {
-    await mkdir(Global.Path.cache, { recursive: true })
-    await writeFile(cacheFile, JSON.stringify(data))
-    if (mtimeMs !== undefined) {
-      const t = mtimeMs / 1000
-      await utimes(cacheFile, t, t)
-    }
-  })
-
-const provided = <A, E>(state: Ref.Ref<MockState>, eff: Effect.Effect<A, E, ModelsDev.Service>) =>
-  eff.pipe(Effect.provide(buildLayer(state)))
-
-beforeEach(async () => {
-  await rm(cacheFile, { force: true })
-})
-
-afterAll(async () => {
-  await rm(cacheFile, { force: true })
-})
-
-const initialState: MockState = {
-  body: JSON.stringify(fixture),
-  status: 200,
-  calls: [],
-}
-// ModelsDev.get() filters/injects providers based on Config.get() (saeeol-allowed gating,
-// apertis options, saeeol provider injection). The test setup doesn't provide an Instance
-// context, so Config.get() throws "No context found for instance".
-describe.skip("ModelsDev Service", () => {
-  it.live("get() returns providers from disk when cache file exists", () =>
-    Effect.gen(function* () {
-      yield* writeCache(fixture)
-      const state = yield* Ref.make(initialState)
-      const result = yield* provided(
-        state,
-        ModelsDev.Service.use((s) => s.get()),
-      )
-      expect(result).toEqual(fixture)
-      const final = yield* Ref.get(state)
-      expect(final.calls).toEqual([])
-    }),
-  )
-
-  it.live("get() returns {} when disk empty and fetch disabled", () =>
-    Effect.gen(function* () {
-      const state = yield* Ref.make(initialState)
-      const result = yield* provided(
-        state,
-        ModelsDev.Service.use((s) => s.get()),
-      )
-      expect(result).toEqual({})
-      const final = yield* Ref.get(state)
-      expect(final.calls).toEqual([])
-    }),
-  )
-
-  it.live("get() is single-flight under concurrent calls", () =>
-    Effect.gen(function* () {
-      yield* writeCache(fixture)
-      const state = yield* Ref.make(initialState)
-      const results = yield* provided(
-        state,
-        Effect.gen(function* () {
-          const svc = yield* ModelsDev.Service
-          return yield* Effect.all([svc.get(), svc.get(), svc.get(), svc.get(), svc.get()], {
-            concurrency: "unbounded",
-          })
-        }),
-      )
-      for (const result of results) expect(result).toEqual(fixture)
-    }),
-  )
-
-  it.live("get() caches across calls (later disk writes are ignored until invalidate)", () =>
-    Effect.gen(function* () {
-      yield* writeCache(fixture)
-      const state = yield* Ref.make(initialState)
-      const first = yield* provided(
-        state,
-        Effect.gen(function* () {
-          const svc = yield* ModelsDev.Service
-          const a = yield* svc.get()
-          // mutate disk between calls — cache should mask the change
-          yield* writeCache(fixture2)
-          const b = yield* svc.get()
-          return { a, b }
-        }),
-      )
-      expect(first.a).toEqual(fixture)
-      expect(first.b).toEqual(fixture)
-    }),
-  )
-
-  it.live("refresh(true) fetches via HttpClient and updates the cache", () =>
-    Effect.gen(function* () {
-      yield* writeCache(fixture)
-      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
-      const result = yield* provided(
-        state,
-        Effect.gen(function* () {
-          const svc = yield* ModelsDev.Service
-          const before = yield* svc.get()
-          yield* svc.refresh(true)
-          const after = yield* svc.get()
-          return { before, after }
-        }),
-      )
-      expect(result.before).toEqual(fixture)
-      expect(result.after).toEqual(fixture2)
-      const final = yield* Ref.get(state)
-      expect(final.calls.length).toBe(1)
-      expect(final.calls[0].url).toContain("/api.json")
-    }),
-  )
-
-  it.live("refresh(false) skips fetch when on-disk file is fresh", () =>
-    Effect.gen(function* () {
-      // Fresh: mtime within the 5-minute TTL.
-      yield* writeCache(fixture, Date.now() - 1000)
-      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
-      yield* provided(
-        state,
-        ModelsDev.Service.use((s) => s.refresh(false)),
-      )
-      const final = yield* Ref.get(state)
-      expect(final.calls).toEqual([])
-    }),
-  )
-
-  it.live("refresh(false) fetches when on-disk file is stale", () =>
-    Effect.gen(function* () {
-      // Stale: mtime 10 minutes ago, beyond the 5-minute TTL.
-      yield* writeCache(fixture, Date.now() - 10 * 60 * 1000)
-      const state = yield* Ref.make({ ...initialState, body: JSON.stringify(fixture2) })
-      const after = yield* provided(
-        state,
-        Effect.gen(function* () {
-          const svc = yield* ModelsDev.Service
-          yield* svc.refresh(false)
-          return yield* svc.get()
-        }),
-      )
-      const final = yield* Ref.get(state)
-      expect(final.calls.length).toBe(1)
-      expect(after).toEqual(fixture2)
-    }),
-  )
-
-  it.live("refresh swallows HTTP errors and leaves cache intact", () =>
-    Effect.gen(function* () {
-      yield* writeCache(fixture)
-      const state = yield* Ref.make({ ...initialState, status: 500, body: "boom" })
-      const result = yield* provided(
-        state,
-        Effect.gen(function* () {
-          const svc = yield* ModelsDev.Service
-          yield* svc.refresh(true)
-          return yield* svc.get()
-        }),
-      )
-      expect(result).toEqual(fixture)
-      // withTransientReadRetry retries 5xx, so calls may be > 1.
-      const final = yield* Ref.get(state)
-      expect(final.calls.length).toBeGreaterThanOrEqual(1)
-    }),
-  )
-})

package/test/provider/provider-category.test.ts

@@ -1,190 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { Schema } from "effect"
-import { Provider } from "@/provider/provider"
-import { ProviderID, ModelID } from "../../src/provider/schema"
-import { LOCAL_PROVIDERS, CUSTOM_PROVIDERS, CLOUD_PROVIDERS } from "@/provider/custom-loaders"
-import { ProviderCategory, Info } from "@/provider/provider-schemas"
-
-const local = LOCAL_PROVIDERS as readonly string[]
-const custom = CUSTOM_PROVIDERS as readonly string[]
-const cloud = CLOUD_PROVIDERS as readonly string[]
-
-describe("provider category constants", () => {
-  test("LOCAL_PROVIDERS contains expected local providers", () => {
-    expect(local).toContain("ollama")
-    expect(local).toContain("lmstudio")
-    expect(local).toContain("vllm")
-    expect(local).toContain("text-generation-webui")
-    expect(local).toContain("llama.cpp")
-  })
-
-  test("CUSTOM_PROVIDERS contains expected custom providers", () => {
-    expect(custom).toContain("openrouter")
-    expect(custom).toContain("llmgateway")
-    expect(custom).toContain("nvidia")
-    expect(custom).toContain("vercel")
-    expect(custom).toContain("zenmux")
-    expect(custom).toContain("cerebras")
-  })
-
-  test("CLOUD_PROVIDERS contains expected cloud providers", () => {
-    expect(cloud).toContain("anthropic")
-    expect(cloud).toContain("openai")
-    expect(cloud).toContain("xai")
-    expect(cloud).toContain("saeeol")
-    expect(cloud).toContain("azure")
-    expect(cloud).toContain("amazon-bedrock")
-    expect(cloud).toContain("google-vertex")
-    expect(cloud).toContain("google-vertex-anthropic")
-    expect(cloud).toContain("github-copilot")
-  })
-
-  test("no overlap between categories", () => {
-    const localSet = new Set(local)
-    const customSet = new Set(custom)
-    const cloudSet = new Set(cloud)
-
-    for (const id of localSet) {
-      expect(customSet.has(id as string)).toBe(false)
-      expect(cloudSet.has(id as string)).toBe(false)
-    }
-    for (const id of customSet) {
-      expect(localSet.has(id as string)).toBe(false)
-      expect(cloudSet.has(id as string)).toBe(false)
-    }
-  })
-
-  test("all arrays are non-empty", () => {
-    expect(local.length).toBeGreaterThan(0)
-    expect(custom.length).toBeGreaterThan(0)
-    expect(cloud.length).toBeGreaterThan(0)
-  })
-})
-
-describe("ProviderCategory schema", () => {
-  test("ProviderCategory accepts valid values", () => {
-    for (const val of ["local", "custom", "cloud"] as const) {
-      const result = Schema.decodeSync(ProviderCategory)(val)
-      expect(result).toBe(val)
-    }
-  })
-
-  test("ProviderCategory rejects invalid values", () => {
-    expect(() => Schema.decodeSync(ProviderCategory)("invalid" as any)).toThrow()
-  })
-})
-
-describe("Info schema with category", () => {
-  function makeInfo(cat: "local" | "custom" | "cloud") {
-    return {
-      id: "test" as any,
-      name: "Test",
-      category: cat,
-      source: "config" as const,
-      env: [] as string[],
-      options: {} as Record<string, any>,
-      models: {} as Record<string, any>,
-    }
-  }
-
-  test("Info decodes with category field", () => {
-    const parsed = Schema.decodeSync(Info)(makeInfo("cloud"))
-    expect(parsed.category).toBe("cloud")
-  })
-
-  test("Info rejects missing category", () => {
-    const missing = {
-      id: "test" as any,
-      name: "Test",
-      source: "config" as const,
-      env: [] as string[],
-      options: {} as Record<string, any>,
-      models: {} as Record<string, any>,
-    }
-    expect(() => Schema.decodeSync(Info)(missing as any)).toThrow()
-  })
-
-  test("Info accepts all valid categories", () => {
-    for (const cat of ["local", "custom", "cloud"] as const) {
-      expect(Schema.decodeSync(Info)(makeInfo(cat)).category).toBe(cat)
-    }
-  })
-})
-
-describe("getCategory classification", () => {
-  function getCategory(id: string): "local" | "custom" | "cloud" {
-    if (local.includes(id)) return "local"
-    if (custom.includes(id)) return "custom"
-    return "cloud"
-  }
-
-  test("local providers classified correctly", () => {
-    expect(getCategory("ollama")).toBe("local")
-    expect(getCategory("lmstudio")).toBe("local")
-    expect(getCategory("vllm")).toBe("local")
-    expect(getCategory("text-generation-webui")).toBe("local")
-    expect(getCategory("llama.cpp")).toBe("local")
-  })
-
-  test("custom providers classified correctly", () => {
-    expect(getCategory("openrouter")).toBe("custom")
-    expect(getCategory("llmgateway")).toBe("custom")
-    expect(getCategory("nvidia")).toBe("custom")
-    expect(getCategory("vercel")).toBe("custom")
-    expect(getCategory("cerebras")).toBe("custom")
-  })
-
-  test("cloud providers classified correctly", () => {
-    expect(getCategory("anthropic")).toBe("cloud")
-    expect(getCategory("openai")).toBe("cloud")
-    expect(getCategory("saeeol")).toBe("cloud")
-    expect(getCategory("github-copilot")).toBe("cloud")
-  })
-
-  test("unknown providers default to cloud", () => {
-    expect(getCategory("some-new-provider")).toBe("cloud")
-    expect(getCategory("future-ai")).toBe("cloud")
-  })
-})
-
-describe("fromModelsDevProvider assigns category", () => {
-  test("fromModelsDevProvider returns custom category", () => {
-    const { fromModelsDevProvider } = require("@/provider/provider-schemas")
-    const mockProvider = {
-      id: "test-provider",
-      name: "Test Provider",
-      env: [],
-      models: {
-        "test-model": {
-          id: "test-model",
-          name: "Test Model",
-          limit: { context: 4096, output: 2048 },
-          cost: {},
-        },
-      },
-    }
-    const result = fromModelsDevProvider(mockProvider)
-    expect(result.category).toBe("custom")
-  })
-})
-
-describe("provider re-exports", () => {
-  test("Provider exports ProviderCategory", () => {
-    expect(Provider.ProviderCategory).toBeDefined()
-  })
-
-  test("Provider exports LOCAL_PROVIDERS", () => {
-    expect(Provider.LOCAL_PROVIDERS).toBeDefined()
-    expect(Provider.LOCAL_PROVIDERS).toContain("ollama")
-  })
-
-  test("Provider exports CUSTOM_PROVIDERS", () => {
-    expect(Provider.CUSTOM_PROVIDERS).toBeDefined()
-    expect(Provider.CUSTOM_PROVIDERS).toContain("openrouter")
-  })
-
-  test("Provider exports CLOUD_PROVIDERS", () => {
-    expect(Provider.CLOUD_PROVIDERS).toBeDefined()
-    expect(Provider.CLOUD_PROVIDERS).toContain("anthropic")
-  })
-})