openAgent

1import { describe, expect } from "bun:test"
2import { Directory } from "@/acp/directory"
3import { Command } from "@/command"
4import { LayerNode } from "@opencode-ai/core/effect/layer-node"
5import { ProviderV2 } from "@opencode-ai/core/provider"
6import { ModelV2 } from "@opencode-ai/core/model"
7import { Provider } from "@/provider/provider"
8import { Effect, Layer } from "effect"
9import { it } from "../lib/effect"
10 
11const command = (name: string): Command.Info => ({
12  name,
13  source: "command",
14  template: `run ${name}`,
15  hints: [],
16})
17 
18const model = (providerID: ProviderV2.ID, id: string, variants?: Directory.ModelVariants): Provider.Model => ({
19  id: ModelV2.ID.make(id),
20  providerID,
21  api: {
22    id,
23    url: "https://example.com",
24    npm: "@ai-sdk/openai-compatible",
25  },
26  name: id,
27  family: "test",
28  capabilities: {
29    temperature: true,
30    reasoning: Boolean(variants),
31    attachment: false,
32    toolcall: true,
33    input: { text: true, audio: false, image: false, video: false, pdf: false },
34    output: { text: true, audio: false, image: false, video: false, pdf: false },
35    interleaved: false,
36  },
37  cost: {
38    input: 0,
39    output: 0,
40    cache: { read: 0, write: 0 },
41  },
42  limit: {
43    context: 128000,
44    output: 4096,
45  },
46  status: "active",
47  options: {},
48  headers: {},
49  release_date: "2026-01-01",
50  ...(variants ? { variants } : {}),
51})
52 
53const snapshot = (directory: string) => {
54  const providerID = ProviderV2.ID.make(`provider-${directory}`)
55  const modelID = ModelV2.ID.make(`model-${directory}`)
56  const providers = {
57    [providerID]: {
58      id: providerID,
59      name: `Provider ${directory}`,
60      source: "config",
61      env: [],
62      options: {},
63      models: {
64        [modelID]: model(providerID, modelID, {
65          low: { reasoningEffort: "low" },
66          high: { reasoningEffort: "high" },
67        }),
68        [ModelV2.ID.make(`plain-${directory}`)]: model(providerID, `plain-${directory}`),
69      },
70    },
71  } satisfies Record<ProviderV2.ID, Provider.Info>
72 
73  return Directory.build({
74    directory,
75    providers,
76    modes: [
77      { id: "build", name: `build-${directory}` },
78      { id: "plan", name: `plan-${directory}`, description: "plan first" },
79    ],
80    defaultModeID: "build",
81    commands: [command(`init-${directory}`), command(`review-${directory}`)],
82    defaultModel: { providerID, modelID },
83  })
84}
85 
86const fakeLayer = (calls: string[]) =>
87  LayerNode.compile(Directory.node, [
88    [
89      Directory.loaderNode,
90      Layer.succeed(
91        Directory.Loader,
92        Directory.Loader.of({
93          load: (directory) =>
94            Effect.sync(() => {
95              calls.push(directory)
96              return snapshot(directory)
97            }),
98        }),
99      ),
100    ],
101  ])
102 
103describe("ACP directory snapshot", () => {
104  it.effect("two concurrent callers share one load", () => {
105    const calls: string[] = []
106    return Effect.gen(function* () {
107      const directory = yield* Directory.Service
108      const [first, second] = yield* Effect.all([directory.get("alpha"), directory.get("alpha")], {
109        concurrency: "unbounded",
110      })
111 
112      expect(calls).toEqual(["alpha"])
113      expect(first).toBe(second)
114    }).pipe(Effect.provide(fakeLayer(calls)))
115  })
116 
117  it.effect("warm calls use cached data", () => {
118    const calls: string[] = []
119    return Effect.gen(function* () {
120      const directory = yield* Directory.Service
121      const first = yield* directory.get("alpha")
122      const second = yield* directory.get("alpha")
123 
124      expect(calls).toEqual(["alpha"])
125      expect(first).toBe(second)
126    }).pipe(Effect.provide(fakeLayer(calls)))
127  })
128 
129  it.effect("different directories get different snapshots", () => {
130    const calls: string[] = []
131    return Effect.gen(function* () {
132      const directory = yield* Directory.Service
133      const [alpha, beta] = yield* Effect.all([directory.get("alpha"), directory.get("beta")], {
134        concurrency: "unbounded",
135      })
136 
137      expect(calls.toSorted()).toEqual(["alpha", "beta"])
138      expect(alpha.directory).toBe("alpha")
139      expect(beta.directory).toBe("beta")
140      expect(alpha.defaultModel?.providerID).not.toBe(beta.defaultModel?.providerID)
141    }).pipe(Effect.provide(fakeLayer(calls)))
142  })
143 
144  it.effect("model variant lookup works", () =>
145    Effect.gen(function* () {
146      const directory = yield* Directory.Service
147      const alpha = yield* directory.get("alpha")
148      const model = alpha.defaultModel!
149 
150      expect(directory.variants(alpha, model)).toEqual({
151        low: { reasoningEffort: "low" },
152        high: { reasoningEffort: "high" },
153      })
154      expect(directory.variants(alpha, { ...model, modelID: ModelV2.ID.make("missing") })).toBeUndefined()
155    }).pipe(Effect.provide(fakeLayer([]))),
156  )
157 
158  it.effect("commands and modes are included", () =>
159    Effect.gen(function* () {
160      const directory = yield* Directory.Service
161      const alpha = yield* directory.get("alpha")
162 
163      expect(alpha.availableCommands.map((item) => item.name)).toEqual(["init-alpha", "review-alpha"])
164      expect(alpha.availableModes).toEqual([
165        { id: "build", name: "build-alpha" },
166        { id: "plan", name: "plan-alpha", description: "plan first" },
167      ])
168      expect(alpha.defaultModeID).toBe("build")
169    }).pipe(Effect.provide(fakeLayer([]))),
170  )
171 
172  it.effect("falls back when the default mode is not available", () =>
173    Effect.sync(() => {
174      expect(
175        Directory.build({
176          directory: "alpha",
177          providers: {},
178          modes: [
179            { id: "build", name: "Build" },
180            { id: "plan", name: "Plan" },
181          ],
182          defaultModeID: "hidden",
183          commands: [],
184        }).defaultModeID,
185      ).toBe("build")
186    }),
187  )
188})
189