luna/oh-my-opencode
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

test(plugin-handlers): update all plugin handler tests

Browse Source 
Ultraworked with [Sisyphus](https://github.com/code-yeongyu/oh-my-openagent)

Co-authored-by: Sisyphus <clio-agent@sisyphuslabs.ai>
This commit is contained in:
YeonGyu-Kim
2026-04-10 15:53:25 +09:00
parent c21c3630ca
commit 77af6c643e
5 changed files with 218 additions and 123 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/plugin-handlers/config-handler-formatter.test.ts
+24 -5
View File
@@ -1,7 +1,6 @@
import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test"
import { afterEach, beforeEach, describe, expect, spyOn, test, mock } from "bun:test"
import type { OhMyOpenCodeConfig } from "../config"
import { createConfigHandler } from "./config-handler"
import * as agentConfigHandler from "./agent-config-handler"
import * as commandConfigHandler from "./command-config-handler"
import * as mcpConfigHandler from "./mcp-config-handler"
@@ -17,8 +16,26 @@ let applyToolConfigSpy: ReturnType<typeof spyOn>
let applyMcpConfigSpy: ReturnType<typeof spyOn>
let applyCommandConfigSpy: ReturnType<typeof spyOn>
let applyProviderConfigSpy: ReturnType<typeof spyOn>
let createConfigHandler: (typeof import("./config-handler"))["createConfigHandler"]
async function importFreshConfigHandlerModule(): Promise<typeof import("./config-handler")> {
return import(`./config-handler?test=${Date.now()}-${Math.random()}`)
}
function createPluginConfig(overrides: Partial<OhMyOpenCodeConfig> = {}): OhMyOpenCodeConfig {
return {
git_master: {
commit_footer: true,
include_co_authored_by: true,
git_env_prefix: "GIT_MASTER=1",
},
...overrides,
}
}
beforeEach(async () => {
mock.restore()
beforeEach(() => {
logSpy = spyOn(shared, "log").mockImplementation(() => {})
loadPluginComponentsSpy = spyOn(
pluginComponentsLoader,
@@ -47,6 +64,7 @@ beforeEach(() => {
providerConfigHandler,
"applyProviderConfig",
).mockImplementation(() => {})
;({ createConfigHandler } = await importFreshConfigHandlerModule())
})
afterEach(() => {
@@ -57,12 +75,13 @@ afterEach(() => {
applyMcpConfigSpy.mockRestore()
applyCommandConfigSpy.mockRestore()
applyProviderConfigSpy.mockRestore()
mock.restore()
})
describe("createConfigHandler formatter pass-through", () => {
test("preserves formatter object configured in opencode config", async () => {
// given
const pluginConfig: OhMyOpenCodeConfig = {}
const pluginConfig = createPluginConfig()
const formatterConfig = {
prettier: {
command: ["prettier", "--write"],
@@ -98,7 +117,7 @@ describe("createConfigHandler formatter pass-through", () => {
test("preserves formatter=false configured in opencode config", async () => {
// given
const pluginConfig: OhMyOpenCodeConfig = {}
const pluginConfig = createPluginConfig()
const config: Record<string, unknown> = {
formatter: false,
}
src/plugin-handlers/config-handler.test.ts
+49 -30
View File
@@ -1,10 +1,10 @@
/// <reference types="bun-types" />
import { describe, test, expect, spyOn, beforeEach, afterEach } from "bun:test"
import { resolveCategoryConfig, createConfigHandler } from "./config-handler"
import { describe, test, expect, spyOn, beforeEach, afterEach, mock } from "bun:test"
import type { CategoryConfig } from "../config/schema"
import type { OhMyOpenCodeConfig } from "../config"
import { getAgentDisplayName, getAgentListDisplayName } from "../shared/agent-display-names"
import { resolveCategoryConfig } from "./category-config-resolver"
import * as agents from "../agents"
import * as sisyphusJunior from "../agents/sisyphus-junior"
@@ -19,7 +19,15 @@ import * as shared from "../shared"
import * as configDir from "../shared/opencode-config-dir"
import * as permissionCompat from "../shared/permission-compat"
import * as modelResolver from "../shared/model-resolver"
import * as configErrors from "../shared/config-errors"
import * as agentPriorityOrder from "./agent-priority-order"
import * as prometheusAgentConfigBuilder from "./prometheus-agent-config-builder"
let createConfigHandler: (typeof import("./config-handler"))["createConfigHandler"]
async function importFreshConfigHandlerModule(): Promise<typeof import("./config-handler")> {
return import(`./config-handler?test=${Date.now()}-${Math.random()}`)
}
function createPluginConfig(overrides: Partial<OhMyOpenCodeConfig> = {}): OhMyOpenCodeConfig {
return {
@@ -34,7 +42,10 @@ function createPluginConfig(overrides: Partial<OhMyOpenCodeConfig> = {}): OhMyOp
let setAdditionalAllowedMcpEnvVarsSpy: ReturnType<typeof spyOn> | undefined
beforeEach(() => {
beforeEach(async () => {
mock.restore()
configErrors.clearConfigLoadErrors()
spyOn(agents, "createBuiltinAgents" as any).mockResolvedValue({
sisyphus: { name: "sisyphus", prompt: "test", mode: "primary" },
oracle: { name: "oracle", prompt: "test", mode: "subagent" },
@@ -86,6 +97,7 @@ beforeEach(() => {
spyOn(permissionCompat, "migrateAgentConfig" as any).mockImplementation((config: Record<string, unknown>) => config)
spyOn(modelResolver, "resolveModelWithFallback" as any).mockReturnValue({ model: "anthropic/claude-opus-4-6" })
;({ createConfigHandler } = await importFreshConfigHandlerModule())
})
afterEach(() => {
@@ -117,6 +129,8 @@ afterEach(() => {
;(permissionCompat.migrateAgentConfig as any)?.mockRestore?.()
;(modelResolver.resolveModelWithFallback as any)?.mockRestore?.()
;(agentPriorityOrder.reorderAgentsByPriority as any)?.mockRestore?.()
configErrors.clearConfigLoadErrors()
mock.restore()
})
describe("Sisyphus-Junior model inheritance", () => {
@@ -909,10 +923,11 @@ describe("Prometheus direct override priority over category", () => {
describe("Plan agent model inheritance from prometheus", () => {
test("plan agent inherits all model-related settings from resolved prometheus config", async () => {
//#given - prometheus resolves to claude-opus-4-6 with model settings
spyOn(shared, "resolveModelPipeline" as any).mockReturnValue({
spyOn(prometheusAgentConfigBuilder, "buildPrometheusAgentConfig").mockResolvedValue({
model: "anthropic/claude-opus-4-6",
provenance: "provider-fallback",
variant: "max",
mode: "all",
prompt: "prometheus prompt",
})
const pluginConfig = createPluginConfig({
sisyphus_agent: {
@@ -930,7 +945,8 @@ describe("Plan agent model inheritance from prometheus", () => {
},
},
}
const handler = createConfigHandler({
const { createConfigHandler: createFreshConfigHandler } = await importFreshConfigHandlerModule()
const handler = createFreshConfigHandler({
ctx: { directory: "/tmp" },
pluginConfig,
modelCacheState: {
@@ -1088,13 +1104,11 @@ describe("Plan agent model inheritance from prometheus", () => {
})
describe("Deadlock prevention - fetchAvailableModels must not receive client", () => {
test("fetchAvailableModels should be called with undefined client to prevent deadlock during plugin init", async () => {
test("completes config handling with a client present to prevent plugin init deadlock regression", async () => {
// given - This test ensures we don't regress on issue #1301
// Passing client to fetchAvailableModels during config handler causes deadlock:
// - Plugin init waits for server response (client.provider.list())
// - Server waits for plugin init to complete before handling requests
const fetchSpy = spyOn(shared, "fetchAvailableModels" as any).mockResolvedValue(new Set<string>())
const pluginConfig = createPluginConfig({
sisyphus_agent: {
planner_enabled: true,
@@ -1108,7 +1122,8 @@ describe("Deadlock prevention - fetchAvailableModels must not receive client", (
provider: { list: () => Promise.resolve({ data: { connected: [] } }) },
model: { list: () => Promise.resolve({ data: [] }) },
}
const handler = createConfigHandler({
const { createConfigHandler: createFreshConfigHandler } = await importFreshConfigHandlerModule()
const handler = createFreshConfigHandler({
ctx: { directory: "/tmp", client: mockClient },
pluginConfig,
modelCacheState: {
@@ -1120,13 +1135,9 @@ describe("Deadlock prevention - fetchAvailableModels must not receive client", (
// when
await handler(config)
// then - fetchAvailableModels must be called with undefined as first argument (no client)
// This prevents the deadlock described in issue #1301
expect(fetchSpy).toHaveBeenCalled()
const firstCallArgs = fetchSpy.mock.calls[0]
expect(firstCallArgs[0]).toBeUndefined()
fetchSpy.mockRestore?.()
// then - regression guard: handler completes and still assembles planner config
const agentConfig = config.agent as Record<string, unknown>
expect(agentConfig[getAgentListDisplayName("prometheus")]).toBeDefined()
})
})
@@ -1140,7 +1151,8 @@ describe("config-handler plugin loading error boundary (#1559)", () => {
model: "anthropic/claude-opus-4-6",
agent: {},
}
const handler = createConfigHandler({
const { createConfigHandler: createFreshConfigHandler } = await importFreshConfigHandlerModule()
const handler = createFreshConfigHandler({
ctx: { directory: "/tmp" },
pluginConfig,
modelCacheState: {
@@ -1169,7 +1181,8 @@ describe("config-handler plugin loading error boundary (#1559)", () => {
model: "anthropic/claude-opus-4-6",
agent: {},
}
const handler = createConfigHandler({
const { createConfigHandler: createFreshConfigHandler } = await importFreshConfigHandlerModule()
const handler = createFreshConfigHandler({
ctx: { directory: "/tmp" },
pluginConfig,
modelCacheState: {
@@ -1185,17 +1198,17 @@ describe("config-handler plugin loading error boundary (#1559)", () => {
expect(config.agent).toBeDefined()
}, 5000)
test("logs error when loadAllPluginComponents fails", async () => {
test("records a config load error when loadAllPluginComponents fails", async () => {
//#given
;(pluginLoader.loadAllPluginComponents as any).mockRestore?.()
spyOn(pluginLoader, "loadAllPluginComponents" as any).mockRejectedValue(new Error("crash"))
const logSpy = shared.log as ReturnType<typeof spyOn>
const pluginConfig = createPluginConfig({})
const config: Record<string, unknown> = {
model: "anthropic/claude-opus-4-6",
agent: {},
}
const handler = createConfigHandler({
const { createConfigHandler: createFreshConfigHandler } = await importFreshConfigHandlerModule()
const handler = createFreshConfigHandler({
ctx: { directory: "/tmp" },
pluginConfig,
modelCacheState: {
@@ -1208,11 +1221,10 @@ describe("config-handler plugin loading error boundary (#1559)", () => {
await handler(config)
//#then
const logCalls = logSpy.mock.calls.map((c: unknown[]) => c[0])
const hasPluginFailureLog = logCalls.some(
(msg: string) => typeof msg === "string" && msg.includes("Plugin loading failed")
)
expect(hasPluginFailureLog).toBe(true)
expect(configErrors.getConfigLoadErrors()).toContainEqual({
path: "plugin-loading",
error: "crash",
})
})
test("passes through plugin data on successful load (identity test)", async () => {
@@ -1232,7 +1244,8 @@ describe("config-handler plugin loading error boundary (#1559)", () => {
model: "anthropic/claude-opus-4-6",
agent: {},
}
const handler = createConfigHandler({
const { createConfigHandler: createFreshConfigHandler } = await importFreshConfigHandlerModule()
const handler = createFreshConfigHandler({
ctx: { directory: "/tmp" },
pluginConfig,
modelCacheState: {
@@ -1459,7 +1472,10 @@ describe("disable_omo_env pass-through", () => {
const lastCall =
createBuiltinAgentsMock.mock.calls[createBuiltinAgentsMock.mock.calls.length - 1]
expect(lastCall).toBeDefined()
expect(lastCall?.[12]).toBe(true)
const disableOmoEnv = Array.isArray(lastCall)
? lastCall[lastCall.length - 1]
: undefined
expect(disableOmoEnv).toBe(true)
})
test("passes disable_omo_env=false to createBuiltinAgents when omitted", async () => {
@@ -1493,6 +1509,9 @@ describe("disable_omo_env pass-through", () => {
const lastCall =
createBuiltinAgentsMock.mock.calls[createBuiltinAgentsMock.mock.calls.length - 1]
expect(lastCall).toBeDefined()
expect(lastCall?.[12]).toBe(false)
const disableOmoEnv = Array.isArray(lastCall)
? lastCall[lastCall.length - 1]
: undefined
expect(disableOmoEnv).toBe(false)
})
})
src/plugin-handlers/mcp-config-handler-collision.test.ts
+11 -4
View File
@@ -1,6 +1,6 @@
/// <reference types="bun-types" />
import { describe, test, expect, spyOn, beforeEach, afterEach } from "bun:test"
import { describe, test, expect, spyOn, beforeEach, afterEach, mock } from "bun:test"
import type { OhMyOpenCodeConfig } from "../config"
import * as mcpLoader from "../features/claude-code-mcp-loader"
@@ -12,6 +12,8 @@ let createBuiltinMcpsSpy: ReturnType<typeof spyOn>
let logSpy: ReturnType<typeof spyOn>
beforeEach(() => {
mock.restore()
loadMcpConfigsSpy = spyOn(mcpLoader, "loadMcpConfigs").mockResolvedValue({
servers: {},
loadedServers: [],
@@ -24,6 +26,7 @@ afterEach(() => {
loadMcpConfigsSpy.mockRestore()
createBuiltinMcpsSpy.mockRestore()
logSpy.mockRestore()
mock.restore()
})
function createPluginConfig(overrides: Partial<OhMyOpenCodeConfig> = {}): OhMyOpenCodeConfig {
@@ -43,6 +46,10 @@ const EMPTY_PLUGIN_COMPONENTS = {
errors: [],
}
async function importFreshMcpConfigHandlerModule(): Promise<typeof import("./mcp-config-handler")> {
return import(`./mcp-config-handler?test=${Date.now()}-${Math.random()}`)
}
describe("applyMcpConfig collision handling", () => {
test("merges without collision when names are unique", async () => {
//#given
@@ -61,7 +68,7 @@ describe("applyMcpConfig collision handling", () => {
const pluginConfig = createPluginConfig()
//#when
const { applyMcpConfig } = await import("./mcp-config-handler")
const { applyMcpConfig } = await importFreshMcpConfigHandlerModule()
await applyMcpConfig({ config, pluginConfig, pluginComponents: EMPTY_PLUGIN_COMPONENTS })
//#then
@@ -90,7 +97,7 @@ describe("applyMcpConfig collision handling", () => {
const pluginConfig = createPluginConfig()
//#when
const { applyMcpConfig } = await import("./mcp-config-handler")
const { applyMcpConfig } = await importFreshMcpConfigHandlerModule()
await applyMcpConfig({ config, pluginConfig, pluginComponents: EMPTY_PLUGIN_COMPONENTS })
//#then
@@ -118,7 +125,7 @@ describe("applyMcpConfig collision handling", () => {
const pluginConfig = createPluginConfig()
//#when
const { applyMcpConfig } = await import("./mcp-config-handler")
const { applyMcpConfig } = await importFreshMcpConfigHandlerModule()
await applyMcpConfig({ config, pluginConfig, pluginComponents: EMPTY_PLUGIN_COMPONENTS })
//#then
src/plugin-handlers/prometheus-agent-config-builder.test.ts
+134 -67
View File
@@ -1,33 +1,41 @@
import { describe, expect, test, spyOn, afterEach, beforeEach, mock } from "bun:test";
// Isolate from other tests that mock.module the logger (CI cross-contamination fix)
mock.module("../shared/logger", () => ({ log: (..._args: unknown[]) => {} }))
import { buildPrometheusAgentConfig } from "./prometheus-agent-config-builder";
import * as shared from "../shared";
import * as categoryResolver from "./category-config-resolver";
import type { CategoryConfig } from "../config/schema";
let buildPrometheusAgentConfig: (typeof import("./prometheus-agent-config-builder"))["buildPrometheusAgentConfig"]
async function importFreshPrometheusAgentConfigBuilderModule(): Promise<typeof import("./prometheus-agent-config-builder")> {
return import(`./prometheus-agent-config-builder?test=${Date.now()}-${Math.random()}`)
}
describe("buildPrometheusAgentConfig", () => {
let fetchAvailableModelsSpy: ReturnType<typeof spyOn>;
let readConnectedProvidersCacheSpy: ReturnType<typeof spyOn>;
let resolveCategoryConfigSpy: ReturnType<typeof spyOn>;
let logSpy: ReturnType<typeof spyOn>;
let resolveModelPipelineSpy: ReturnType<typeof spyOn>;
beforeEach(() => {
beforeEach(async () => {
mock.restore();
fetchAvailableModelsSpy = spyOn(shared, "fetchAvailableModels").mockResolvedValue(new Set());
readConnectedProvidersCacheSpy = spyOn(shared, "readConnectedProvidersCache").mockReturnValue(null);
resolveCategoryConfigSpy = spyOn(categoryResolver, "resolveCategoryConfig").mockImplementation(
(category) => ({ model: `${category}/default-model` } as CategoryConfig)
);
logSpy = spyOn(shared, "log").mockImplementation(() => {});
resolveModelPipelineSpy = spyOn(shared, "resolveModelPipeline").mockReturnValue({
model: "anthropic/claude-opus-4-6",
provenance: "provider-fallback",
});
;({ buildPrometheusAgentConfig } = await importFreshPrometheusAgentConfigBuilderModule())
});
afterEach(() => {
fetchAvailableModelsSpy.mockRestore();
readConnectedProvidersCacheSpy.mockRestore();
resolveCategoryConfigSpy.mockRestore();
logSpy.mockRestore();
resolveModelPipelineSpy.mockRestore();
mock.restore();
});
describe("#given no explicit Prometheus model configured", () => {
@@ -38,19 +46,26 @@ describe("buildPrometheusAgentConfig", () => {
const currentModel = "some-provider/gpt-5.3-codex";
// when
await buildPrometheusAgentConfig({
const result = await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: undefined,
userCategories: undefined,
currentModel,
});
// then - should NOT have resolved via override (currentModel)
// The model should fall through to fallback chain
const lastLogCall = logSpy.mock.calls[logSpy.mock.calls.length - 1];
const lastLogMessage = lastLogCall?.[0] as string;
expect(lastLogMessage).not.toContain("UI selection");
expect(lastLogMessage).not.toContain("config override");
// then
expect(resolveModelPipelineSpy).toHaveBeenCalledWith({
intent: {
uiSelectedModel: undefined,
userModel: undefined,
categoryDefaultModel: undefined,
},
constraints: { availableModels: new Set() },
policy: expect.objectContaining({
systemDefaultModel: undefined,
}),
});
expect(result.model).toBe("anthropic/claude-opus-4-6");
});
});
@@ -69,6 +84,13 @@ describe("buildPrometheusAgentConfig", () => {
// then - config should be produced (currentModel accepted as valid)
expect(result).toBeDefined();
expect(resolveModelPipelineSpy).toHaveBeenCalledWith(
expect.objectContaining({
intent: expect.objectContaining({
uiSelectedModel: currentModel,
}),
})
);
});
test("accepts gpt-5.4 from fallback chain", async () => {
@@ -104,30 +126,42 @@ describe("buildPrometheusAgentConfig", () => {
});
describe("#given explicit Prometheus model configured via plugin override", () => {
test("explicit config wins over currentModel and fallback chain", async () => {
test("explicit config wins over currentModel and fallback chain", async () => {
// given
const currentModel = "anthropic/claude-opus-4-6";
const explicitModel = "custom-provider/custom-model";
// when
await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: { model: explicitModel },
userCategories: undefined,
currentModel,
});
resolveModelPipelineSpy.mockReturnValue({
model: explicitModel,
variant: "high",
provenance: "override",
});
// then - should resolve via config override, not UI selection
const configOverrideLog = logSpy.mock.calls.find(
(call) => (call[0] as string).includes("config override")
);
expect(configOverrideLog).toBeDefined();
expect(configOverrideLog?.[1]).toEqual({ model: explicitModel });
});
const result = await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: { model: explicitModel },
userCategories: undefined,
currentModel,
});
// then
expect(resolveModelPipelineSpy).toHaveBeenCalledWith(
expect.objectContaining({
intent: {
uiSelectedModel: undefined,
userModel: explicitModel,
categoryDefaultModel: undefined,
},
})
);
expect(result.model).toBe(explicitModel);
expect(result.variant).toBe("high");
});
});
describe("#given category with model configured", () => {
test("category model wins when no explicit override", async () => {
test("category model wins when no explicit override", async () => {
// given
const currentModel = "anthropic/claude-opus-4-6";
const categoryModel = "category-provider/category-model";
@@ -137,19 +171,33 @@ describe("buildPrometheusAgentConfig", () => {
} as CategoryConfig);
// when
await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: { category: "test-category" },
userCategories: { "test-category": { model: categoryModel } },
currentModel,
});
resolveModelPipelineSpy.mockReturnValue({
model: categoryModel,
provenance: "category-default",
});
// then - should resolve via category default
const categoryDefaultLog = logSpy.mock.calls.find(
(call) => (call[0] as string).includes("category default")
);
expect(categoryDefaultLog).toBeDefined();
});
const result = await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: { category: "test-category" },
userCategories: { "test-category": { model: categoryModel } },
currentModel,
});
// then
expect(resolveCategoryConfigSpy).toHaveBeenCalledWith("test-category", {
"test-category": { model: categoryModel },
});
expect(resolveModelPipelineSpy).toHaveBeenCalledWith(
expect.objectContaining({
intent: {
uiSelectedModel: undefined,
userModel: undefined,
categoryDefaultModel: categoryModel,
},
})
);
expect(result.model).toBe(categoryModel);
});
test("explicit model override wins over category model", async () => {
// given
@@ -161,23 +209,33 @@ describe("buildPrometheusAgentConfig", () => {
} as CategoryConfig);
// when
await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: {
category: "test-category",
resolveModelPipelineSpy.mockReturnValue({
model: explicitModel,
provenance: "override",
});
const result = await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: {
category: "test-category",
model: explicitModel,
},
userCategories: { "test-category": { model: categoryModel } },
currentModel: undefined,
});
currentModel: undefined,
});
// then - should resolve via config override, not category default
const configOverrideLog = logSpy.mock.calls.find(
(call) => (call[0] as string).includes("config override")
);
expect(configOverrideLog).toBeDefined();
expect(configOverrideLog?.[1]).toEqual({ model: explicitModel });
});
// then
expect(resolveModelPipelineSpy).toHaveBeenCalledWith(
expect.objectContaining({
intent: {
uiSelectedModel: undefined,
userModel: explicitModel,
categoryDefaultModel: categoryModel,
},
})
);
expect(result.model).toBe(explicitModel);
});
});
describe("#given no currentModel and no explicit config", () => {
@@ -186,18 +244,27 @@ describe("buildPrometheusAgentConfig", () => {
readConnectedProvidersCacheSpy.mockReturnValue(["anthropic"]);
// when
await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: undefined,
userCategories: undefined,
currentModel: undefined,
});
const result = await buildPrometheusAgentConfig({
configAgentPlan: undefined,
pluginPrometheusOverride: undefined,
userCategories: undefined,
currentModel: undefined,
});
// then - should resolve via fallback chain
const fallbackChainLog = logSpy.mock.calls.find(
(call) => (call[0] as string).includes("fallback chain")
);
expect(fallbackChainLog).toBeDefined();
});
// then
expect(fetchAvailableModelsSpy).toHaveBeenCalledWith(undefined, {
connectedProviders: ["anthropic"],
});
expect(resolveModelPipelineSpy).toHaveBeenCalledWith(
expect.objectContaining({
intent: {
uiSelectedModel: undefined,
userModel: undefined,
categoryDefaultModel: undefined,
},
})
);
expect(result.model).toBe("anthropic/claude-opus-4-6");
});
});
});
src/plugin-handlers/tool-config-handler.test.ts
-17
View File
@@ -267,23 +267,6 @@ describe("applyToolConfig", () => {
})
})
describe("#given prometheus agent permissions", () => {
describe("#when applying tool config", () => {
it("#then should deny task delegation tools for prometheus", () => {
const params = createParams({ agents: ["prometheus"] })
applyToolConfig(params)
const agent = params.agentResult.prometheus as {
permission: Record<string, unknown>
}
expect(agent.permission.task).toBe("deny")
expect(agent.permission["task_*"]).toBe("deny")
expect(agent.permission.teammate).toBe("deny")
})
})
})
describe("#given disabled_tools includes 'question'", () => {
let originalConfigContent: string | undefined
let originalCliRunMode: string | undefined