saeeol 1.2.5 → 1.2.7

package/test/saeeol/provider-cost.test.ts

@@ -1,171 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Session as SessionNs } from "@/session/session"
-import type { Provider } from "@/provider/provider"
-
-function createModel(opts: {
-  context: number
-  output: number
-  input?: number
-  cost?: Provider.Model["cost"]
-  npm?: string
-}): Provider.Model {
-  return {
-    id: "test-model",
-    providerID: "test",
-    name: "Test",
-    limit: {
-      context: opts.context,
-      input: opts.input,
-      output: opts.output,
-    },
-    cost: opts.cost ?? { input: 0, output: 0, cache: { read: 0, write: 0 } },
-    capabilities: {
-      toolcall: true,
-      attachment: false,
-      reasoning: false,
-      temperature: true,
-      input: { text: true, image: false, audio: false, video: false },
-      output: { text: true, image: false, audio: false, video: false },
-    },
-    api: { npm: opts.npm ?? "@ai-sdk/anthropic" },
-    options: {},
-  } as Provider.Model
-}
-
-const baseUsage = {
-  inputTokens: 1_000_000,
-  outputTokens: 100_000,
-  totalTokens: 1_100_000,
-  inputTokenDetails: { noCacheTokens: undefined, cacheReadTokens: undefined, cacheWriteTokens: undefined },
-  outputTokenDetails: { textTokens: undefined, reasoningTokens: undefined },
-}
-
-const model = () =>
-  createModel({
-    context: 100_000,
-    output: 32_000,
-    cost: { input: 3, output: 15, cache: { read: 0.3, write: 3.75 } },
-  })
-
-const saeeol = { id: "saeeol" } as Provider.Info
-
-// Calculated cost for the `model()` + `baseUsage` pair: 1M input * $3 + 100k output * $15 = 3 + 1.5
-const fallback = 3 + 1.5
-
-describe("SaeeolSession.providerCost — Anthropic Messages / OpenAI Responses", () => {
-  test("uses usage.raw.cost_details.upstream_inference_cost for Anthropic Messages via OpenRouter", () => {
-    const result = SessionNs.getUsage({
-      model: model(),
-      provider: saeeol,
-      usage: {
-        ...baseUsage,
-        // `convertAnthropicUsage` copies the verbatim provider usage onto `raw`.
-        // Top-level `cost` is the OpenRouter fee and must be ignored.
-        raw: {
-          input_tokens: 1,
-          output_tokens: 1121,
-          cache_creation_input_tokens: 5385,
-          cache_read_input_tokens: 106831,
-          cost: 0.0057550875,
-          is_byok: true,
-          cost_details: {
-            upstream_inference_cost: 0.11510175,
-          },
-        },
-      },
-    })
-
-    expect(result.cost).toBe(0.11510175)
-  })
-
-  test("uses usage.raw.cost_details.upstream_inference_cost for OpenAI Responses via OpenRouter", () => {
-    const result = SessionNs.getUsage({
-      model: model(),
-      provider: saeeol,
-      usage: {
-        ...baseUsage,
-        // `convertOpenAIResponsesUsage` copies the verbatim provider usage onto `raw`.
-        raw: {
-          input_tokens: 622051,
-          input_tokens_details: { cached_tokens: 594944 },
-          output_tokens: 304,
-          output_tokens_details: { reasoning_tokens: 0 },
-          total_tokens: 622355,
-          cost: 0.0439847,
-          is_byok: true,
-          cost_details: {
-            upstream_inference_cost: 0.879694,
-            upstream_inference_input_cost: 0.866014,
-            upstream_inference_output_cost: 0.01368,
-          },
-        },
-      },
-    })
-
-    expect(result.cost).toBe(0.879694)
-  })
-
-  test("ignores raw `cost` when no upstream_inference_cost is reported", () => {
-    const result = SessionNs.getUsage({
-      model: model(),
-      provider: saeeol,
-      usage: {
-        ...baseUsage,
-        raw: {
-          cost: 0.5,
-          // cost_details missing
-        },
-      },
-    })
-
-    expect(result.cost).toBe(fallback)
-  })
-})
-
-describe("SaeeolSession.providerCost — Vercel AI Gateway", () => {
-  test("uses metadata.gateway.marketCost", () => {
-    const result = SessionNs.getUsage({
-      model: model(),
-      provider: saeeol,
-      usage: baseUsage,
-      metadata: {
-        gateway: {
-          // Strings, exactly as emitted by the AI Gateway. `cost` is the gateway fee,
-          // which Saeeol doesn't pass on to end users — must be ignored.
-          cost: "0",
-          marketCost: "0.35349075",
-        },
-      },
-    })
-
-    expect(result.cost).toBe(0.35349075)
-  })
-
-  test("ignores metadata.gateway.cost when marketCost is missing", () => {
-    const result = SessionNs.getUsage({
-      model: model(),
-      provider: saeeol,
-      usage: baseUsage,
-      metadata: {
-        gateway: {
-          cost: "0.123",
-        },
-      },
-    })
-
-    expect(result.cost).toBe(fallback)
-  })
-})
-
-describe("SaeeolSession.providerCost — fallback", () => {
-  test("falls back to calculated cost when no provider cost is reported", () => {
-    const result = SessionNs.getUsage({
-      model: model(),
-      provider: saeeol,
-      usage: baseUsage,
-      // No metadata, no usage.raw — should fall back
-    })
-
-    expect(result.cost).toBe(fallback)
-  })
-})

package/test/saeeol/provider-list-failed-state.test.ts

@@ -1,100 +0,0 @@
-// Verifies that:
-//   1. ModelCache.failedProviders() surfaces providers that encountered errors.
-//   2. ModelCache.getFailure() returns the typed error for a failed provider.
-//   3. Clear removes failure state.
-
-import { test, expect, mock } from "bun:test"
-import path from "path"
-import * as Log from "@saeeol/core/util/log"
-
-Log.init({ print: false })
-
-// Stub fetchSaeeolModels to return controlled typed results.
-let stubbedResult: { models: Record<string, any>; error?: { kind: string; status?: number } } = { models: {} }
-
-mock.module("@saeeol/gateway", () => ({
-  fetchSaeeolModels: async () => stubbedResult,
-  SAEEOL_OPENROUTER_BASE: "https://api.saeeol.ai/api/openrouter",
-}))
-
-mock.module("saeeol-copilot-auth", () => ({ default: () => ({}) }))
-mock.module("saeeol-anthropic-auth", () => ({ default: () => ({}) }))
-mock.module("@gitlab/saeeol-gitlab-auth", () => ({ default: () => ({}) }))
-
-import { tmpdir } from "../fixture/fixture"
-import { Instance } from "../../src/project/instance"
-import { ModelCache } from "../../src/provider/model-cache"
-
-const CONFIG = JSON.stringify({ $schema: "https://app.saeeol.ai/config.json" })
-
-async function withInstance<T>(fn: () => Promise<T>): Promise<T> {
-  await using tmp = await tmpdir({
-    init: async (dir) => {
-      await Bun.write(path.join(dir, "saeeol.json"), CONFIG)
-    },
-  })
-  return Instance.provide({ directory: tmp.path, fn })
-}
-
-test("failedProviders returns empty array when no fetch has occurred", () => {
-  ModelCache.clear("saeeol")
-  expect(ModelCache.failedProviders()).not.toContain("saeeol")
-})
-
-test("getFailure returns undefined when fetch succeeds", async () => {
-  stubbedResult = {
-    models: {
-      "test/model": {
-        id: "test/model",
-        name: "Test",
-        cost: { input: 1, output: 2 },
-        limit: { context: 128000, output: 4096 },
-      },
-    },
-  }
-  ModelCache.clear("saeeol")
-  await withInstance(() => ModelCache.fetch("saeeol"))
-  expect(ModelCache.getFailure("saeeol")).toBeUndefined()
-  expect(ModelCache.failedProviders()).not.toContain("saeeol")
-})
-
-test("failedProviders includes provider after auth error", async () => {
-  stubbedResult = { models: {}, error: { kind: "unauthorized", status: 401 } }
-  ModelCache.clear("saeeol")
-  await withInstance(() => ModelCache.fetch("saeeol"))
-  expect(ModelCache.failedProviders()).toContain("saeeol")
-  expect(ModelCache.getFailure("saeeol")).toMatchObject({ kind: "unauthorized", status: 401 })
-})
-
-test("clear removes failure state", async () => {
-  stubbedResult = { models: {}, error: { kind: "network" } }
-  ModelCache.clear("saeeol")
-  await withInstance(() => ModelCache.fetch("saeeol"))
-  expect(ModelCache.failedProviders()).toContain("saeeol")
-
-  ModelCache.clear("saeeol")
-  expect(ModelCache.failedProviders()).not.toContain("saeeol")
-  expect(ModelCache.getFailure("saeeol")).toBeUndefined()
-})
-
-test("failure state is cleared when subsequent fetch succeeds", async () => {
-  stubbedResult = { models: {}, error: { kind: "unauthorized", status: 401 } }
-  ModelCache.clear("saeeol")
-  await withInstance(() => ModelCache.fetch("saeeol"))
-  expect(ModelCache.failedProviders()).toContain("saeeol")
-
-  stubbedResult = {
-    models: {
-      "test/model": {
-        id: "test/model",
-        name: "Test",
-        cost: { input: 1, output: 2 },
-        limit: { context: 128000, output: 4096 },
-      },
-    },
-  }
-  ModelCache.clear("saeeol")
-  await withInstance(() => ModelCache.fetch("saeeol"))
-  expect(ModelCache.failedProviders()).not.toContain("saeeol")
-  expect(ModelCache.getFailure("saeeol")).toBeUndefined()
-})

package/test/saeeol/question-dismiss-all.test.ts

@@ -1,174 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Effect } from "effect"
-import { SaeeolSessionPromptQueue } from "../../src/overlay/session/prompt-queue"
-import { Instance } from "../../src/project/instance"
-import { Question } from "../../src/question"
-import { MessageID, SessionID } from "../../src/session/schema"
-import { tmpdir } from "../fixture/fixture"
-
-describe("Question.dismissAll", () => {
-  test("rejects pending asks for the target session and clears them", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const sesA = SessionID.make("ses_a")
-        const sesB = SessionID.make("ses_b")
-
-        const a1 = Question.ask({
-          sessionID: sesA,
-          questions: [
-            {
-              header: "Continue?",
-              question: "Should I continue?",
-              options: [
-                { label: "Yes", description: "Go" },
-                { label: "No", description: "Stop" },
-              ],
-            },
-          ],
-        }).catch((err) => {
-          if (err instanceof Question.RejectedError) return "rejected"
-          throw err
-        })
-
-        const a2 = Question.ask({
-          sessionID: sesA,
-          questions: [
-            {
-              header: "Retry?",
-              question: "Try again?",
-              options: [
-                { label: "Retry", description: "Retry" },
-                { label: "Cancel", description: "Cancel" },
-              ],
-            },
-          ],
-        }).catch((err) => {
-          if (err instanceof Question.RejectedError) return "rejected"
-          throw err
-        })
-
-        const b1 = Question.ask({
-          sessionID: sesB,
-          questions: [
-            {
-              header: "Deploy?",
-              question: "Deploy now?",
-              options: [
-                { label: "Ship", description: "Ship" },
-                { label: "Wait", description: "Wait" },
-              ],
-            },
-          ],
-        }).catch((err) => {
-          if (err instanceof Question.RejectedError) return "rejected-b"
-          throw err
-        })
-
-        // Wait for all three asks to register so we can dismiss them.
-        for (let i = 0; i < 50; i++) {
-          if ((await Question.list()).length >= 3) break
-          await Bun.sleep(10)
-        }
-        expect(await Question.list()).toHaveLength(3)
-
-        // Track whether B's promise settles.
-        let settled = false
-        b1.then(() => {
-          settled = true
-        })
-
-        await Question.dismissAll("ses_a")
-
-        expect(await a1).toBe("rejected")
-        expect(await a2).toBe("rejected")
-
-        await new Promise((r) => setTimeout(r, 10))
-        expect(settled).toBe(false)
-
-        const remaining = await Question.list()
-        expect(remaining).toHaveLength(1)
-        expect(remaining[0]?.sessionID).toBe(sesB)
-
-        await Question.reject(remaining[0]!.id)
-        expect(await b1).toBe("rejected-b")
-      },
-    })
-  })
-
-  test("is a no-op when no questions exist", async () => {
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        await Question.dismissAll("ses_missing")
-        expect(await Question.list()).toEqual([])
-      },
-    })
-  })
-
-  test("ask rejects immediately when a followup is queued on the session", async () => {
-    // When a newer prompt has already been enqueued on the session, a tool
-    // that subsequently calls Question.ask would otherwise block the run until
-    // the user manually dismisses it. Verify the pre-emptive hasFollowup check
-    // rejects with RejectedError before any pending entry is registered.
-    await using tmp = await tmpdir({ git: true })
-    await Instance.provide({
-      directory: tmp.path,
-      fn: async () => {
-        const sessionID = SessionID.make("ses_auto_ask")
-        const started = Promise.withResolvers<void>()
-        const release = Promise.withResolvers<void>()
-
-        // Slot 1 stays running so activeSince is pinned to its seq.
-        const first = Effect.runPromise(
-          SaeeolSessionPromptQueue.enqueue(
-            sessionID,
-            MessageID.make("message_ask_1"),
-            Effect.gen(function* () {
-              started.resolve()
-              yield* Effect.promise(() => release.promise)
-              return "first" as const
-            }),
-            Effect.succeed("first-cancelled" as const),
-          ),
-        )
-        await started.promise
-
-        // Slot 2 arrives while slot 1 is active — latest > activeSince.
-        const second = Effect.runPromise(
-          SaeeolSessionPromptQueue.enqueue(
-            sessionID,
-            MessageID.make("message_ask_2"),
-            Effect.succeed("second" as const),
-            Effect.succeed("second-cancelled" as const),
-          ),
-        )
-        await Bun.sleep(10)
-        expect(SaeeolSessionPromptQueue.hasFollowup(sessionID)).toBe(true)
-
-        await expect(
-          Question.ask({
-            sessionID,
-            questions: [
-              {
-                header: "Continue?",
-                question: "Should I continue?",
-                options: [
-                  { label: "Yes", description: "Go" },
-                  { label: "No", description: "Stop" },
-                ],
-              },
-            ],
-          }),
-        ).rejects.toBeInstanceOf(Question.RejectedError)
-        expect(await Question.list()).toEqual([])
-
-        release.resolve()
-        expect(await first).toBe("first")
-        expect(await second).toBe("second")
-      },
-    })
-  })
-})

package/test/saeeol/read-directory.test.ts

@@ -1,116 +0,0 @@
-import { describe, expect } from "bun:test"
-import { Effect, Layer } from "effect"
-import { symlink } from "fs/promises"
-import path from "path"
-import { Agent } from "../../src/agent/agent"
-import * as CrossSpawnSpawner from "@saeeol/core/cross-spawn-spawner"
-import { AppFileSystem } from "@saeeol/core/filesystem"
-import { LSP } from "../../src/lsp/lsp"
-import { Instruction } from "../../src/session/instruction"
-import { Truncate } from "../../src/tool/truncate"
-import { MessageID, SessionID } from "../../src/session/schema"
-import { ReadTool } from "../../src/tool/read"
-import { Tool } from "../../src/tool/tool"
-import { provideInstance, tmpdirScoped } from "../fixture/fixture"
-import { testEffect } from "../lib/effect"
-
-const baseCtx = {
-  sessionID: SessionID.make("ses_test"),
-  messageID: MessageID.make(""),
-  callID: "",
-  agent: "code",
-  abort: AbortSignal.any([]),
-  messages: [],
-  metadata: () => {},
-  ask: () => Effect.void,
-}
-
-const expandCtx = { ...baseCtx, extra: { includeDirectoryFiles: true } }
-
-const it = testEffect(
-  Layer.mergeAll(
-    Agent.defaultLayer,
-    AppFileSystem.defaultLayer,
-    CrossSpawnSpawner.defaultLayer,
-    Instruction.defaultLayer,
-    LSP.defaultLayer,
-    Truncate.defaultLayer,
-  ),
-)
-
-const init = Effect.fn("ReadDirectoryTest.init")(function* () {
-  const info = yield* ReadTool
-  return yield* Tool.init(info)
-})
-
-const run = Effect.fn("ReadDirectoryTest.run")(function* (
-  args: Tool.InferParameters<typeof ReadTool>,
-  ctx = expandCtx,
-) {
-  const tool = yield* init()
-  return yield* tool.execute(args, ctx as any)
-})
-
-const exec = Effect.fn("ReadDirectoryTest.exec")(function* (
-  dir: string,
-  args: Tool.InferParameters<typeof ReadTool>,
-  ctx = expandCtx,
-) {
-  return yield* provideInstance(dir)(run(args, ctx))
-})
-
-const put = Effect.fn("ReadDirectoryTest.put")(function* (p: string, content: string | Uint8Array) {
-  const fs = yield* AppFileSystem.Service
-  yield* fs.writeWithDirs(p, content)
-})
-
-describe("saeeol directory reads", () => {
-  it.live("includes top-level file contents for directory reads", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "folder", "a.txt"), "alpha")
-      yield* put(path.join(dir, "folder", "nested", "b.txt"), "beta")
-      yield* put(path.join(dir, "folder", "binary.bin"), new Uint8Array([0, 1, 2]))
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "folder") })
-
-      expect(result.output).toContain("a.txt")
-      expect(result.output).toContain('<file_content path="folder/a.txt">\nalpha\n</file_content>')
-      expect(result.output).not.toContain('<file_content path="folder/nested/b.txt">')
-      expect(result.output).not.toContain('<file_content path="folder/binary.bin">')
-      expect(result.metadata.loaded).toContain(path.join(dir, "folder", "a.txt"))
-    }),
-  )
-
-  it.live("skips content inlining without the saeeol flag", () =>
-    Effect.gen(function* () {
-      const dir = yield* tmpdirScoped()
-      yield* put(path.join(dir, "folder", "a.txt"), "alpha")
-
-      const result = yield* exec(dir, { filePath: path.join(dir, "folder") }, baseCtx)
-
-      expect(result.output).toContain("a.txt")
-      expect(result.output).not.toContain('<file_content path="folder/a.txt">')
-      expect(result.metadata.loaded).toEqual([])
-    }),
-  )
-
-  if (process.platform !== "win32") {
-    it.live("skips symlinked top-level files", () =>
-      Effect.gen(function* () {
-        const dir = yield* tmpdirScoped()
-        const outer = yield* tmpdirScoped()
-        yield* put(path.join(dir, "folder", "a.txt"), "alpha")
-        yield* put(path.join(outer, "secret.txt"), "secret")
-        yield* Effect.promise(() => symlink(path.join(outer, "secret.txt"), path.join(dir, "folder", "secret.txt")))
-
-        const result = yield* exec(dir, { filePath: path.join(dir, "folder") })
-
-        expect(result.output).toContain("secret.txt")
-        expect(result.output).not.toContain('<file_content path="folder/secret.txt">')
-        expect(result.output).not.toContain("secret\n</file_content>")
-        expect(result.metadata.loaded).not.toContain(path.join(dir, "folder", "secret.txt"))
-      }),
-    )
-  }
-})