283 lines
10 KiB
TypeScript
283 lines
10 KiB
TypeScript
import { describe, expect } from "bun:test"
|
|
import type {
|
|
AuthenticateResponse,
|
|
CloseSessionResponse,
|
|
InitializeResponse,
|
|
LoadSessionResponse,
|
|
NewSessionResponse,
|
|
ResumeSessionResponse,
|
|
SessionNotification,
|
|
SetSessionConfigOptionResponse,
|
|
} from "@agentclientprotocol/sdk"
|
|
import { Effect } from "effect"
|
|
import { cliIt } from "../../lib/cli-process"
|
|
import { testProviderConfig } from "../../lib/test-provider"
|
|
import { createAcpClient, expectOk, firstAlternateValue, selectConfigOption } from "../acp/acp-test-client"
|
|
|
|
describe("opencode acp-next (subprocess)", () => {
|
|
cliIt.live(
|
|
"responds to initialize behind OPENCODE_ACP_NEXT",
|
|
({ opencode }) =>
|
|
Effect.gen(function* () {
|
|
const acp = createAcpClient(yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } }))
|
|
const initialized = expectOk(
|
|
yield* acp.request<InitializeResponse>("initialize", {
|
|
protocolVersion: 1,
|
|
clientCapabilities: { _meta: { "terminal-auth": true } },
|
|
}),
|
|
)
|
|
|
|
expect(initialized.protocolVersion).toBe(1)
|
|
expect(initialized.agentCapabilities?.promptCapabilities?.embeddedContext).toBe(true)
|
|
expect(initialized.agentCapabilities?.promptCapabilities?.image).toBe(true)
|
|
expect(initialized.agentCapabilities?.mcpCapabilities?.http).toBe(true)
|
|
expect(initialized.agentCapabilities?.mcpCapabilities?.sse).toBe(true)
|
|
expect(initialized.agentCapabilities?.loadSession).toBe(true)
|
|
expect(initialized.agentCapabilities?.sessionCapabilities?.close).toEqual({})
|
|
expect(initialized.agentCapabilities?.sessionCapabilities?.fork).toEqual({})
|
|
expect(initialized.agentCapabilities?.sessionCapabilities?.list).toEqual({})
|
|
expect(initialized.agentCapabilities?.sessionCapabilities?.resume).toEqual({})
|
|
expect(initialized.agentInfo?.name).toBe("OpenCode")
|
|
expect(initialized.authMethods?.[0]?.id).toBe("opencode-login")
|
|
expect(initialized.authMethods?.[0]?._meta?.["terminal-auth"]).toBeDefined()
|
|
}),
|
|
60_000,
|
|
)
|
|
|
|
cliIt.live(
|
|
"authenticate succeeds for the advertised auth method and rejects unknown methods safely",
|
|
({ opencode }) =>
|
|
Effect.gen(function* () {
|
|
const acp = createAcpClient(yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } }))
|
|
const initialized = expectOk(yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 }))
|
|
const methodId = initialized.authMethods?.[0]?.id
|
|
expect(methodId).toBe("opencode-login")
|
|
|
|
expectOk(yield* acp.request<AuthenticateResponse>("authenticate", { methodId }))
|
|
|
|
const rejected = yield* acp.request<AuthenticateResponse>("authenticate", { methodId: "missing-auth-method" })
|
|
expect(errorCode(rejected.error)).toBe(-32602)
|
|
}),
|
|
60_000,
|
|
)
|
|
|
|
cliIt.live(
|
|
"creates and loads sessions behind OPENCODE_ACP_NEXT",
|
|
({ home, llm, opencode }) =>
|
|
Effect.gen(function* () {
|
|
const acp = createAcpClient(
|
|
yield* opencode.acp({
|
|
env: {
|
|
OPENCODE_ACP_NEXT: "1",
|
|
OPENCODE_CONFIG_CONTENT: JSON.stringify(testProviderConfig(llm.url)),
|
|
},
|
|
}),
|
|
)
|
|
yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
|
|
|
|
const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
|
|
expect(typeof session.sessionId).toBe("string")
|
|
expect(selectConfigOption(session.configOptions, "model")?.category).toBe("model")
|
|
|
|
const update = yield* acp.waitForNotification<SessionNotification>(
|
|
"session/update",
|
|
(params) =>
|
|
params.sessionId === session.sessionId && params.update.sessionUpdate === "available_commands_update",
|
|
)
|
|
expect(update.params?.sessionId).toBe(session.sessionId)
|
|
|
|
const loaded = expectOk(
|
|
yield* acp.request<LoadSessionResponse>("session/load", {
|
|
cwd: home,
|
|
sessionId: session.sessionId,
|
|
mcpServers: [],
|
|
}),
|
|
)
|
|
expect(selectConfigOption(loaded.configOptions, "model")?.category).toBe("model")
|
|
|
|
const prompt = yield* acp.request("session/prompt", {
|
|
sessionId: "ses_missing",
|
|
prompt: [{ type: "text", text: "hello" }],
|
|
})
|
|
expect(errorCode(prompt.error)).toBe(-32601)
|
|
}),
|
|
60_000,
|
|
)
|
|
|
|
cliIt.live(
|
|
"switches model through config options behind OPENCODE_ACP_NEXT",
|
|
({ home, llm, opencode }) =>
|
|
Effect.gen(function* () {
|
|
const acp = createAcpClient(
|
|
yield* opencode.acp({
|
|
env: {
|
|
OPENCODE_ACP_NEXT: "1",
|
|
OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url)),
|
|
},
|
|
}),
|
|
)
|
|
yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
|
|
const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
|
|
|
|
const updated = expectOk(
|
|
yield* acp.request<SetSessionConfigOptionResponse>("session/set_config_option", {
|
|
sessionId: session.sessionId,
|
|
configId: "model",
|
|
value: "test/second-model",
|
|
}),
|
|
)
|
|
|
|
expect(selectConfigOption(updated.configOptions, "model")?.currentValue).toBe("test/second-model")
|
|
}),
|
|
60_000,
|
|
)
|
|
|
|
cliIt.live(
|
|
"switches effort through config options behind OPENCODE_ACP_NEXT",
|
|
({ home, llm, opencode }) =>
|
|
Effect.gen(function* () {
|
|
const acp = createAcpClient(
|
|
yield* opencode.acp({
|
|
env: {
|
|
OPENCODE_ACP_NEXT: "1",
|
|
OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url)),
|
|
},
|
|
}),
|
|
)
|
|
yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 })
|
|
const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
|
|
const effort = selectConfigOption(session.configOptions, "effort")
|
|
expect(effort?.category).toBe("thought_level")
|
|
const nextEffort = effort ? firstAlternateValue(effort) : undefined
|
|
expect(nextEffort).toBe("high")
|
|
|
|
const updated = expectOk(
|
|
yield* acp.request<SetSessionConfigOptionResponse>("session/set_config_option", {
|
|
sessionId: session.sessionId,
|
|
configId: "effort",
|
|
value: nextEffort,
|
|
}),
|
|
)
|
|
|
|
expect(selectConfigOption(updated.configOptions, "effort")?.currentValue).toBe(nextEffort)
|
|
}),
|
|
60_000,
|
|
)
|
|
|
|
cliIt.live(
|
|
"advertises and supports close behind OPENCODE_ACP_NEXT",
|
|
({ home, llm, opencode }) =>
|
|
Effect.gen(function* () {
|
|
const acp = createAcpClient(
|
|
yield* opencode.acp({
|
|
env: {
|
|
OPENCODE_ACP_NEXT: "1",
|
|
OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url)),
|
|
},
|
|
}),
|
|
)
|
|
const initialized = expectOk(yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 }))
|
|
expect(initialized.agentCapabilities?.sessionCapabilities?.close).toEqual({})
|
|
const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
|
|
|
|
expectOk(yield* acp.request<CloseSessionResponse>("session/close", { sessionId: session.sessionId }))
|
|
}),
|
|
60_000,
|
|
)
|
|
|
|
cliIt.live(
|
|
"advertises and supports resume behind OPENCODE_ACP_NEXT",
|
|
({ home, llm, opencode }) =>
|
|
Effect.gen(function* () {
|
|
const acp = createAcpClient(
|
|
yield* opencode.acp({
|
|
env: {
|
|
OPENCODE_ACP_NEXT: "1",
|
|
OPENCODE_CONFIG_CONTENT: JSON.stringify(verifierConfig(llm.url)),
|
|
},
|
|
}),
|
|
)
|
|
const initialized = expectOk(yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 }))
|
|
expect(initialized.agentCapabilities?.sessionCapabilities?.resume).toEqual({})
|
|
const session = expectOk(yield* acp.request<NewSessionResponse>("session/new", { cwd: home, mcpServers: [] }))
|
|
const resumed = expectOk(
|
|
yield* acp.request<ResumeSessionResponse>("session/resume", {
|
|
cwd: home,
|
|
sessionId: session.sessionId,
|
|
mcpServers: [],
|
|
}),
|
|
)
|
|
|
|
expect(selectConfigOption(resumed.configOptions, "model")?.category).toBe("model")
|
|
}),
|
|
60_000,
|
|
)
|
|
|
|
cliIt.live(
|
|
"exits cleanly when flagged stdin is closed",
|
|
({ opencode }) =>
|
|
Effect.gen(function* () {
|
|
const exitedPromise = yield* Effect.scoped(
|
|
Effect.gen(function* () {
|
|
const acp = yield* opencode.acp({ env: { OPENCODE_ACP_NEXT: "1" } })
|
|
return acp.exited
|
|
}),
|
|
)
|
|
|
|
const code = yield* Effect.promise(() => exitedPromise)
|
|
expect(typeof code === "number" || code === null).toBe(true)
|
|
}),
|
|
60_000,
|
|
)
|
|
|
|
cliIt.live(
|
|
"default unflagged path still uses production ACP",
|
|
({ opencode }) =>
|
|
Effect.gen(function* () {
|
|
const acp = createAcpClient(yield* opencode.acp())
|
|
const initialized = expectOk(yield* acp.request<InitializeResponse>("initialize", { protocolVersion: 1 }))
|
|
|
|
expect(initialized.agentCapabilities?.sessionCapabilities?.close).toEqual({})
|
|
expect(initialized.agentCapabilities?.sessionCapabilities?.resume).toEqual({})
|
|
}),
|
|
60_000,
|
|
)
|
|
})
|
|
|
|
function errorCode(error: unknown) {
|
|
if (!error || typeof error !== "object") return undefined
|
|
if (!("code" in error)) return undefined
|
|
return typeof error.code === "number" ? error.code : undefined
|
|
}
|
|
|
|
function verifierConfig(llmUrl: string) {
|
|
const config = testProviderConfig(llmUrl)
|
|
return {
|
|
...config,
|
|
model: "test/test-model",
|
|
provider: {
|
|
test: {
|
|
...config.provider.test,
|
|
models: {
|
|
"test-model": {
|
|
...config.provider.test.models["test-model"],
|
|
variants: {
|
|
low: {},
|
|
high: {},
|
|
},
|
|
},
|
|
"second-model": {
|
|
...config.provider.test.models["test-model"],
|
|
id: "second-model",
|
|
name: "Second Test Model",
|
|
variants: {
|
|
medium: {},
|
|
max: {},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
}
|