From a98d059db273cb8b1b84085fc42767bbc770ddf0 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 15:18:26 +0000 Subject: [PATCH 1/9] feat(providers): apply shared tools to provider sessions Resolve project tools during session preparation and preserve each provider's approval policy. --- apps/server/src/mcp/resolveAgentTools.ts | 27 +++ .../Adapters/AntigravityAdapterV2.ts | 2 + .../Adapters/ClaudeAdapterV2.test.ts | 152 +++++++++++++++ .../Adapters/ClaudeAdapterV2.ts | 80 +++++++- .../Adapters/CodexAdapterV2.test.ts | 28 +++ .../Adapters/CodexAdapterV2.ts | 33 ++++ .../Adapters/OpenCode2AdapterV2.test.ts | 107 +++++++++++ .../Adapters/OpenCode2AdapterV2.testkit.ts | 1 + ...penCode2OrchestratorV2.integration.test.ts | 1 + .../ProviderSessionManager.test.ts | 31 +++ .../ProviderSessionManager.ts | 33 +++- .../opencode2_fork/opencode_transcript.ndjson | 2 +- .../opencode_transcript.ndjson | 2 +- .../src/provider/Drivers/AntigravityDriver.ts | 1 + .../src/server/adapter.ts | 1 + .../src/server/AcpSessionRuntime.ts | 17 +- packages/provider-acp/src/server/adapter.ts | 65 ++++++- .../provider-core/src/server/mcpSession.ts | 32 +++- .../provider-cursor/src/server/adapter.ts | 19 ++ packages/provider-grok/src/server/adapter.ts | 1 + .../provider-opencode/src/server/adapter.ts | 102 ++++++++-- .../src/server/v2/adapter.ts | 179 +++++++++++++++++- 22 files changed, 872 insertions(+), 44 deletions(-) create mode 100644 apps/server/src/mcp/resolveAgentTools.ts diff --git a/apps/server/src/mcp/resolveAgentTools.ts b/apps/server/src/mcp/resolveAgentTools.ts new file mode 100644 index 0000000000000..bde07687359b2 --- /dev/null +++ b/apps/server/src/mcp/resolveAgentTools.ts @@ -0,0 +1,27 @@ +import type { ProjectId, ResolvedMcpServer, ServerSettings } from "@t3tools/contracts"; +import { resolveProjectSettings } from "@t3tools/shared/projectSettings"; + +import type { McpProviderSessionTools } from "@t3tools/provider-core/server/mcpSession"; + +/** + * A thread's tools from settings whose secrets are already materialized: + * the project's overrides applied, disabled servers dropped. The fingerprint + * covers the full config so a rotated secret also counts as a change; it + * stays on the server and is only ever compared, never sent or logged. + */ +export function resolveAgentTools( + settings: ServerSettings, + projectId: ProjectId | null, +): McpProviderSessionTools { + const effective = resolveProjectSettings(settings, projectId).settings; + const servers: ResolvedMcpServer[] = Object.entries(effective.mcpServers) + .filter(([, server]) => server.enabled) + .map(([name, server]) => ({ name, transport: server.transport })) + .toSorted((left, right) => left.name.localeCompare(right.name)); + const disabledSkills = [...new Set(effective.disabledSkills)].toSorted(); + const fingerprint = + servers.length === 0 && disabledSkills.length === 0 + ? "" + : JSON.stringify({ servers, disabledSkills }); + return { servers, disabledSkills, fingerprint }; +} diff --git a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts index 62b2ec6eac11f..49656ee4434fc 100644 --- a/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/AntigravityAdapterV2.ts @@ -61,6 +61,7 @@ const AntigravityProviderCapabilitiesV2 = { } satisfies OrchestrationV2ProviderCapabilities; export interface AntigravityAdapterV2Options { + readonly environment?: NodeJS.ProcessEnv; readonly instanceId: ProviderInstanceId; readonly selfInvocation: SelfInvocation; readonly makeRuntime: ( @@ -226,6 +227,7 @@ export const makeAntigravityAdapterV2 = Effect.fn("makeAntigravityAdapterV2")(fu host: yield* ProviderHost.ProviderHost, }; return yield* makeAcpAdapterV2({ + ...(options.environment === undefined ? {} : { environment: options.environment }), instanceId: options.instanceId, flavor: makeAntigravityAcpAdapterFlavor({ ...options, ...services }), selfInvocation: options.selfInvocation, diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index 8a06dddeeec10..f9176e58cf2ed 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -15653,3 +15653,155 @@ describe("ClaudeAdapterV2 query message stream", () => { }), ); }); + +describe("ClaudeAdapterV2 user tools", () => { + it.effect("injects Tools settings into a turn without granting user-server approval", () => + Effect.scoped( + Effect.gen(function* () { + const fileSystem = yield* FileSystem.FileSystem; + const idAllocator = yield* IdAllocator.IdAllocatorV2; + const mcpSessions = yield* McpProviderSessions.McpProviderSessions; + const attachmentsDir = yield* fileSystem.makeTempDirectoryScoped({ + prefix: "t3-claude-user-tools-", + }); + let openedOptions: ClaudeAdapterV2.ClaudeAgentSdkQueryOptions | undefined; + const adapter = yield* ClaudeAdapterV2.makeClaudeAdapterV2({ + instanceId: ClaudeAdapterV2.CLAUDE_DEFAULT_INSTANCE_ID, + settings: DEFAULT_CLAUDE_SETTINGS, + environment: {}, + attachmentsDir, + fileSystem, + path: yield* Path.Path, + crypto: yield* Crypto.Crypto, + idAllocator, + queryRunner: { + allocateSessionId: Effect.succeed("native-thread-claude-user-tools"), + open: (input) => + Effect.sync(() => { + openedOptions = input.options; + return { + messages: Stream.never, + offer: () => Effect.void, + setModel: () => Effect.void, + applyFlagSettings: () => Effect.void, + backgroundTasks: () => Effect.succeed(false), + stopTask: () => Effect.void, + setPermissionMode: () => Effect.void, + interrupt: Effect.void, + close: Effect.void, + }; + }), + forkSession: () => Effect.die("unused"), + subagentLaunchToolUseId: () => Effect.succeed(null), + assertComplete: Effect.void, + }, + }); + const threadId = ThreadId.make("thread-claude-user-tools-turn"); + yield* mcpSessions.set({ + environmentId: EnvironmentId.make("environment-claude-user-tools"), + threadId, + providerSessionId: "mcp-session-claude-user-tools", + providerInstanceId: ClaudeAdapterV2.CLAUDE_DEFAULT_INSTANCE_ID, + endpoint: "http://127.0.0.1:43123/mcp", + authorizationHeader: "Bearer secret-claude-token", + browserToolsAvailable: true, + tools: { + servers: [ + { + name: "context7", + transport: { + type: "stdio", + command: "npx", + args: ["context7"], + env: [{ name: "API_TOKEN", value: "stdio-token", sensitive: true }], + }, + }, + { + name: "docs", + transport: { + type: "http", + url: "https://example.com/mcp", + headers: [ + { name: "Authorization", value: "superseded-token", sensitive: true }, + { name: "Authorization", value: "winning-token", sensitive: true }, + ], + }, + }, + ], + disabledSkills: ["grill-me"], + fingerprint: "a", + }, + }); + const runtimePolicy = ProviderAdapter.ProviderAdapterV2RuntimePolicy.make({ + runtimeMode: "approval-required", + interactionMode: "default", + cwd: "/workspace", + }); + const runtime = yield* adapter.openSession({ + threadId, + providerSessionId: ProviderSessionId.make("provider-session-claude-user-tools"), + modelSelection: CLAUDE_TEST_MODEL_SELECTION, + runtimePolicy, + }); + const providerThread = yield* runtime.ensureThread({ + threadId, + modelSelection: CLAUDE_TEST_MODEL_SELECTION, + runtimePolicy, + }); + yield* runtime.startTurn( + makeClaudeTestTurnInput({ + threadId, + providerThread, + now: yield* DateTime.now, + attemptId: RunAttemptId.make("attempt-claude-user-tools"), + text: "Hello.", + attachments: [], + runtimePolicy, + }), + ); + + const servers = openedOptions?.mcpServers; + assert.isDefined(servers?.["t3-code"]); + const commandServer = servers?.context7; + const httpServer = servers?.docs; + assert.isDefined(commandServer); + assert.isDefined(httpServer); + if ( + !commandServer || + !("command" in commandServer) || + !httpServer || + !("headers" in httpServer) + ) { + throw new Error("Expected both user MCP transports in query options"); + } + assert.equal(commandServer.command, "npx"); + assert.deepEqual(commandServer.args, ["context7"]); + const materialized = (value: string | undefined) => { + const reference = value?.match(/^\$\{([^}]+)\}$/)?.[1]; + return reference === undefined ? value : openedOptions?.env?.[reference]; + }; + assert.equal(materialized(commandServer.env?.API_TOKEN), "stdio-token"); + assert.equal(materialized(httpServer.headers?.Authorization), "winning-token"); + assert.equal(openedOptions?.permissionMode, "default"); + assert.isFunction(openedOptions?.canUseTool); + assert.include( + openedOptions?.allowedTools ?? [], + ClaudeAdapterV2.CLAUDE_T3_MCP_TOOL_WILDCARD, + ); + assert.isFalse( + (openedOptions?.allowedTools ?? []).some( + (tool) => tool.startsWith("mcp__context7__") || tool.startsWith("mcp__docs__"), + ), + ); + const settings = openedOptions?.settings; + assert.deepEqual(typeof settings === "object" ? settings.skillOverrides : undefined, { + "grill-me": "off", + }); + }).pipe( + Effect.provide( + Layer.mergeAll(IdAllocator.layer, McpProviderSessions.layer, NodeServices.layer), + ), + ), + ), + ); +}); diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index be276af5f0edf..c686f55d9f1da 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -61,6 +61,7 @@ import { type ChatAttachment, ClaudeSettings, defaultInstanceIdForDriver, + mcpServerVariableRecord, type ModelSelection, type OrchestrationV2ConversationMessage, type OrchestrationV2ExecutionNode, @@ -88,6 +89,8 @@ import { type ProviderRequestKind, type ProviderUserInputAnswers, type ProviderThreadId, + type McpServerVariable, + type ResolvedMcpServer, type RunId, type ThreadId, } from "@t3tools/contracts"; @@ -1198,7 +1201,7 @@ export function makeClaudeQueryOptions(input: { preset: "claude_code" as const, append: buildRuntimeInstructions({ harness: "Claude Code" }) + - (input.mcpServers === undefined ? "" : T3_CODE_ORCHESTRATION_INSTRUCTIONS), + (input.mcpServers?.["t3-code"] === undefined ? "" : T3_CODE_ORCHESTRATION_INSTRUCTIONS), }, ...(Object.keys(extraArgs).length === 0 ? {} : { extraArgs }), }; @@ -1257,17 +1260,24 @@ export function claudeMcpQueryOverrides(input: { }): { readonly allowedTools?: ReadonlyArray; readonly mcpServers?: ClaudeQueryOptions["mcpServers"]; + readonly sdkSettings?: ClaudeSdkSettings; + readonly mcpEnvironment?: Readonly>; } { const session = input.mcpSession; if (session === undefined) { return input.allowedTools === undefined ? {} : { allowedTools: input.allowedTools }; } + const tools = session.tools ?? McpProviderSession.EMPTY_MCP_PROVIDER_SESSION_TOOLS; const mcpAllowedTools = input.readOnlySandbox ? CLAUDE_READ_ONLY_T3_MCP_ALLOWED_TOOLS : [CLAUDE_T3_MCP_TOOL_WILDCARD]; + // The user's servers are not pre-approved: full access already skips the + // prompt, so an allow rule would only bypass the modes that ask to approve. + const userServers = claudeUserMcpServers(tools.servers); return { allowedTools: Array.from(new Set([...(input.allowedTools ?? []), ...mcpAllowedTools])), mcpServers: { + ...userServers.mcpServers, "t3-code": { type: "http", url: session.endpoint, @@ -1277,9 +1287,67 @@ export function claudeMcpQueryOverrides(input: { timeout: CLAUDE_T3_MCP_TOOL_TIMEOUT_MS, }, }, + ...(tools.disabledSkills.length === 0 + ? {} + : { + // The flag-settings layer outranks the user's and project's + // settings files, so an "off" here hides the skill from both the + // model and the slash menu whatever those files say. + sdkSettings: { + skillOverrides: Object.fromEntries( + tools.disabledSkills.map((name) => [name, "off" as const]), + ), + }, + }), + ...(Object.keys(userServers.environment).length === 0 + ? {} + : { mcpEnvironment: userServers.environment }), }; } +/** + * The user's servers for `--mcp-config`. Like T3's own token, a sensitive + * env value or header becomes a `${VAR}` reference there, and its value goes + * into the child's environment. + */ +function claudeUserMcpServers(servers: ReadonlyArray): { + readonly mcpServers: NonNullable; + readonly environment: Readonly>; +} { + const environment: Record = {}; + const values = (variables: ReadonlyArray) => { + const record = mcpServerVariableRecord(variables); + // A repeated name keeps its last entry, as the record does. + const sensitive = new Map(variables.map((variable) => [variable.name, variable.sensitive])); + for (const name of Object.keys(record)) { + if (sensitive.get(name) !== true) continue; + // Indexed, so two names that read the same once uppercased stay apart. + const reference = `T3_MCP_SECRET_${Object.keys(environment).length}`; + environment[reference] = record[name]!; + record[name] = `\${${reference}}`; + } + return record; + }; + const mcpServers = Object.fromEntries( + servers.map((server) => [ + server.name, + server.transport.type === "stdio" + ? { + type: "stdio" as const, + command: server.transport.command, + args: [...server.transport.args], + env: values(server.transport.env), + } + : { + type: "http" as const, + url: server.transport.url, + headers: values(server.transport.headers), + }, + ]), + ); + return { mcpServers, environment }; +} + function providerSession(input: { readonly providerSessionId: OrchestrationV2ProviderSession["id"]; readonly providerInstanceId: ProviderInstanceId; @@ -1918,6 +1986,8 @@ export function claudeEffectiveQueryPolicyKey( mcpOverrides: { readonly allowedTools?: ReadonlyArray; readonly mcpServers?: ClaudeQueryOptions["mcpServers"]; + readonly sdkSettings?: ClaudeSdkSettings; + readonly mcpEnvironment?: Readonly>; }, ): string { return JSON.stringify({ @@ -1928,6 +1998,9 @@ export function claudeEffectiveQueryPolicyKey( : { allowedTools: mcpOverrides.allowedTools }), }), mcpServers: mcpOverrides.mcpServers, + // Skill switches load at process start, so a change reopens the query. + sdkSettings: mcpOverrides.sdkSettings, + mcpEnvironment: mcpOverrides.mcpEnvironment, }); } @@ -8525,7 +8598,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( cwd: turnInput.runtimePolicy.cwd, attachmentsDir, settings: adapterOptions.settings, - environment: adapterOptions.environment, + environment: { ...adapterOptions.environment, ...mcpOverrides.mcpEnvironment }, tools: queryPolicy.tools ?? CLAUDE_CODE_PRESET_TOOLS, ...(mcpOverrides.allowedTools === undefined ? {} @@ -8533,6 +8606,9 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( ...(mcpOverrides.mcpServers === undefined ? {} : { mcpServers: mcpOverrides.mcpServers }), + ...(mcpOverrides.sdkSettings === undefined + ? {} + : { sdkSettings: mcpOverrides.sdkSettings }), permissionMode: queryPolicy.permissionMode, ...(queryPolicy.allowDangerouslySkipPermissions === undefined ? {} diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts index 51d072951b4e0..d05d4ef3357c7 100644 --- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts @@ -677,6 +677,34 @@ describe("CodexAdapterV2 process spawning", () => { }, }, ); + const configured = CodexAdapterV2.codexThreadRuntimeParams({ + mcpSession: { + ...mcpSession, + tools: { + servers: [ + { + name: "docs", + transport: { + type: "http", + url: "https://example.com/mcp", + headers: [{ name: "Authorization", value: "user-token", sensitive: true }], + }, + }, + ], + disabledSkills: ["review"], + fingerprint: "user-tools", + }, + }, + }).config; + assert.deepEqual(configured.mcp_servers, { + docs: { url: "https://example.com/mcp", http_headers: { Authorization: "user-token" } }, + "t3-code": { + url: mcpSession.endpoint, + tool_timeout_sec: 3_900, + http_headers: { Authorization: mcpSession.authorizationHeader }, + }, + }); + assert.deepEqual(configured.skills, { config: [{ name: "review", enabled: false }] }); }); it.effect("resolves Windows command shims through the shared spawn policy", () => diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts index 928ae4a7e13a5..6332c2d6af507 100644 --- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts @@ -28,6 +28,7 @@ import { CodexSettings, defaultInstanceIdForDriver, isOrchestrationV2WorkActive, + mcpServerVariableRecord, OrchestrationV2ProviderGoal, ProviderDriverKind, type ProviderSetupError, @@ -66,6 +67,7 @@ import type { ProviderThreadId, ProviderTurnId, ProviderInstanceId, + ResolvedMcpServer, RuntimeMode, RuntimeRequestId, ThreadId, @@ -1306,6 +1308,7 @@ export function codexThreadRuntimeParams(input: { readonly config: Readonly>; } { const { mcpSession } = input; + const tools = mcpSession?.tools ?? McpProviderSession.EMPTY_MCP_PROVIDER_SESSION_TOOLS; return { ...(input.runtimePolicy?.cwd == null ? {} : { cwd: input.runtimePolicy.cwd }), ...(input.modelSelection === undefined ? {} : { model: input.modelSelection.model }), @@ -1315,6 +1318,7 @@ export function codexThreadRuntimeParams(input: { ? {} : { mcp_servers: { + ...codexUserMcpServers(tools.servers), "t3-code": { url: mcpSession.endpoint, tool_timeout_sec: CODEX_T3_MCP_TOOL_TIMEOUT_SEC, @@ -1324,10 +1328,39 @@ export function codexThreadRuntimeParams(input: { }, }, }), + // Thread config is Codex's session-flags layer, which its skill rules + // read alongside the user's config.toml; a later name rule wins. + ...(tools.disabledSkills.length === 0 + ? {} + : { + skills: { + config: tools.disabledSkills.map((name) => ({ name, enabled: false })), + }, + }), }, }; } +function codexUserMcpServers( + servers: ReadonlyArray, +): Record { + return Object.fromEntries( + servers.map((server) => [ + server.name, + server.transport.type === "stdio" + ? { + command: server.transport.command, + args: [...server.transport.args], + env: mcpServerVariableRecord(server.transport.env), + } + : { + url: server.transport.url, + http_headers: mcpServerVariableRecord(server.transport.headers), + }, + ]), + ); +} + const decodeCodexResumeMetadata = Schema.decodeUnknownEffect( Schema.Struct({ thread: Schema.Struct({ id: Schema.String, updatedAt: Schema.Number }) }), ); diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts index 6a56b55400afd..6e1260e38cef1 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts @@ -80,6 +80,7 @@ const durable = { durable: { aggregateID: SESSION, seq: 1, version: 1 } }; const mcpRules = [ { action: "t3-code-*", resource: "*", effect: "deny" }, { action: "t3-code-thread_opencode2-adapter_*", resource: "*", effect: "allow" }, + { action: "t3u-*", resource: "*", effect: "deny" }, ]; const t3Rules = [{ action: "*", resource: "*", effect: "allow" }, ...mcpRules]; const TITLE = "Prime check"; @@ -3244,6 +3245,110 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { }).pipe(Effect.scoped), ); + it.effect( + "retries failed user MCP registrations without reconnecting healthy servers or bypassing approval", + () => + Effect.gen(function* () { + const mcpSessions = yield* McpProviderSessions.McpProviderSessions; + yield* mcpSessions.set({ + environmentId: EnvironmentId.make("environment:opencode2-adapter"), + threadId, + providerSessionId: "mcp:opencode2-adapter", + providerInstanceId: instanceId, + endpoint: "http://127.0.0.1:3773/mcp", + authorizationHeader: "Bearer thread-credential", + browserToolsAvailable: false, + tools: { + servers: ["healthy", "retry"].map((name) => ({ + name, + transport: { type: "http" as const, url: `https://${name}.example/mcp`, headers: [] }, + })), + disabledSkills: [], + fingerprint: "two-servers", + }, + }); + yield* Effect.addFinalizer(() => mcpSessions.clear(threadId)); + const prefix = "t3u-c26f2f1f"; + const ownRules = [ + ...supervisedRules, + { action: `${prefix}-*`, resource: "*", effect: "ask" }, + ]; + const t3Server = "t3-code-thread_opencode2-adapter"; + const addT3 = out("mcp.add", { + server: t3Server, + "location[directory]": WORK, + config: { + type: "remote", + url: "http://127.0.0.1:3773/mcp", + headers: { Authorization: "Bearer thread-credential" }, + oauth: false, + }, + }); + const addUser = (name: string) => + out("mcp.add", { + server: `${prefix}-${name}`, + "location[directory]": WORK, + config: { type: "remote", url: `https://${name}.example/mcp`, headers: {} }, + }); + const turn = [ + out("session.prompt", { sessionID: SESSION, text: "" }), + promptAccepted, + event("session.execution.succeeded", { sessionID: SESSION }), + ]; + const runtime = yield* openCode2ReplayRuntime([ + ...opening, + out("session.get", { sessionID: SESSION }), + replyData("session.get", sessionInfo()), + ...noOpenRequests, + out("agent.list", ""), + reply("agent.list", agentList), + out("session.update", { sessionID: SESSION, permissions: ownRules }), + reply("session.update", null), + addT3, + reply("mcp.add", null), + addUser("healthy"), + reply("mcp.add", null), + addUser("retry"), + reply("mcp.add", { status: 500, body: { message: "Unavailable" } }), + out("session.instructions.entry.put", { + sessionID: SESSION, + key: "t3-code", + value: "", + }), + reply("session.instructions.entry.put", null), + ...turn, + addT3, + reply("mcp.add", null), + out("mcp.list", { "location[directory]": WORK }), + reply("mcp.list", { + location: { directory: WORK }, + data: [{ name: `${prefix}-healthy`, status: { status: "connected" } }], + }), + addUser("retry"), + reply("mcp.add", null), + ...turn, + out("mcp.remove", { server: t3Server, "location[directory]": WORK }), + reply("mcp.remove", null), + out("mcp.remove", { server: `${prefix}-healthy`, "location[directory]": WORK }), + out("mcp.remove", { server: `${prefix}-retry`, "location[directory]": WORK }), + reply("mcp.remove", null), + reply("mcp.remove", null), + ]); + const thread = yield* runtime.resumeThread({ + providerThread: providerThread(yield* DateTime.now), + threadId, + modelSelection: bigPickle, + runtimePolicy: policy("approval-required"), + }); + for (let index = 0; index < 2; index++) { + const terminal = yield* terminalOf(runtime).pipe(Effect.forkScoped); + yield* runtime.startTurn(turnInput(thread, bigPickle, "approval-required")); + assert.equal((yield* Fiber.join(terminal))?.status, "completed"); + } + yield* runtime.unloadThread!({ providerThread: thread }); + }).pipe(Effect.scoped), + ); + it.effect("re-registers T3 MCP each turn and drops its instructions when adding fails", () => Effect.gen(function* () { const mcpSessions = yield* McpProviderSessions.McpProviderSessions; @@ -3325,6 +3430,7 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { { action: "*", resource: "*", effect: "allow" }, { action: "t3-code-*", resource: "*", effect: "deny" }, { action: `${server}_*`, resource: "*", effect: "allow" }, + { action: "t3u-*", resource: "*", effect: "deny" }, ], }), ), @@ -4314,6 +4420,7 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { { action: "*", resource: "*", effect: "allow" }, { action: "t3-code-*", resource: "*", effect: "deny" }, { action: "t3-code-thread_opencode2-adapter_fork_*", resource: "*", effect: "allow" }, + { action: "t3u-*", resource: "*", effect: "deny" }, ], }), reply("session.update", null), diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts index 6edb8d4e1942c..7b1610a31e0e0 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts @@ -57,6 +57,7 @@ const operationOf = ( if (method === "POST" && path === "/api/session") return { type: "session.create", input: body }; if (method === "GET" && path === "/api/session/active") return { type: "session.active" }; if (method === "GET" && path === "/api/command") return { type: "command.list", input: query }; + if (method === "GET" && path === "/api/mcp") return { type: "mcp.list", input: query }; const mcp = /^\/api\/experimental\/mcp\/([^/]+)$/.exec(path); if (mcp !== null && method === "PUT") { return { type: "mcp.add", input: { server: mcp[1], ...query, ...(body as object) } }; diff --git a/apps/server/src/orchestration-v2/OpenCode2OrchestratorV2.integration.test.ts b/apps/server/src/orchestration-v2/OpenCode2OrchestratorV2.integration.test.ts index 18037701cbeb3..a428d9e9121d3 100644 --- a/apps/server/src/orchestration-v2/OpenCode2OrchestratorV2.integration.test.ts +++ b/apps/server/src/orchestration-v2/OpenCode2OrchestratorV2.integration.test.ts @@ -73,6 +73,7 @@ const labelled = (entry: ProviderReplayEntry, label: string): ProviderReplayEntr const mcpRules = (name: string) => [ { action: "t3-code-*", resource: "*", effect: "deny" }, { action: `t3-code-thread_${name}_*`, resource: "*", effect: "allow" }, + { action: "t3u-*", resource: "*", effect: "deny" }, ]; const FULL_ACCESS = [{ action: "*", resource: "*", effect: "allow" }]; diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts index 56db053920a27..f37b648e5b8ed 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts @@ -1916,6 +1916,17 @@ it.effect( const captured = (yield* Ref.get(mcpConfigs))[0]; assert.isDefined(captured); assert.equal(captured?.browserToolsAvailable, false); + assert.deepEqual(captured?.tools?.servers, [ + { + name: "docs", + transport: { + type: "http", + url: "https://example.com/mcp", + headers: [{ name: "Authorization", value: "provider-secret", sensitive: true }], + }, + }, + ]); + assert.deepEqual(captured?.tools?.disabledSkills, ["review"]); const token = captured?.authorizationHeader.replace(/^Bearer\s+/, ""); const resolved = yield* registry.resolve(token!); assert.deepEqual( @@ -1934,6 +1945,26 @@ it.effect( mcpConfigs, serverSettingsLayer: ServerSettings.layerTest({ enableAgentBrowserAccess: false, + disabledSkills: ["review"], + mcpServers: { + docs: { + enabled: true, + transport: { + type: "http", + url: "https://example.com/mcp", + headers: [{ name: "Authorization", value: "provider-secret", sensitive: true }], + }, + }, + disabled: { + enabled: false, + transport: { + type: "stdio", + command: "must-not-start", + args: [], + env: [], + }, + }, + }, }).pipe(Layer.orDie), }), ), diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.ts index edcaecfa88489..ee26cabef464a 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.ts @@ -43,6 +43,8 @@ import { import { ProviderWorkspaceMissingError } from "../provider/Errors.ts"; import * as ProjectService from "../project/ProjectService.ts"; import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; +import { EMPTY_MCP_PROVIDER_SESSION_TOOLS } from "@t3tools/provider-core/server/mcpSession"; +import { resolveAgentTools } from "../mcp/resolveAgentTools.ts"; import * as ServerSettings from "../serverSettings.ts"; import * as McpSessionRegistry from "../mcp/McpSessionRegistry.ts"; import * as EventSink from "./EventSink.ts"; @@ -331,7 +333,12 @@ export const layerWithOptions = ( const agentScope = yield* AgentScope; const agentAccessSettings = Effect.fn("ProviderSessionManagerV2.agentAccessSettings")( function* (threadId: ThreadId) { - if (Option.isNone(serverSettings)) return { browser: true, device: false }; + if (Option.isNone(serverSettings)) + return { + browser: true, + device: false, + tools: EMPTY_MCP_PROVIDER_SESSION_TOOLS, + }; return yield* Effect.gen(function* () { const settings = yield* serverSettings.value.getSettings; const thread = yield* projectionStore.getThread(threadId); @@ -350,19 +357,27 @@ export const layerWithOptions = ( return { browser: browserOverridden ? false : settings.enableAgentBrowserAccess, device: deviceOverridden ? false : settings.enableAgentDeviceAccess, + tools: resolveAgentTools(settings, null), }; } const effective = resolveProjectSettings(settings, thread.projectId).settings; return { browser: effective.enableAgentBrowserAccess, device: effective.enableAgentDeviceAccess, + tools: resolveAgentTools(settings, thread.projectId), }; }).pipe( Effect.catch((cause) => Effect.logWarning( - "Could not resolve agent access; withholding browser and device tools.", + "Could not resolve agent access; withholding browser, device and user tools.", { threadId, cause }, - ).pipe(Effect.as({ browser: false, device: false })), + ).pipe( + Effect.as({ + browser: false, + device: false, + tools: EMPTY_MCP_PROVIDER_SESSION_TOOLS, + }), + ), ), ); }, @@ -449,8 +464,11 @@ export const layerWithOptions = ( // the credential it started with, so a thread that detaches and // re-attaches across a workspace handoff must come back to the // same token or the process's tool calls fail auth. - const { browser: browserToolsAvailable, device: deviceToolsAvailable } = - yield* agentAccessSettings(threadId); + const { + browser: browserToolsAvailable, + device: deviceToolsAvailable, + tools, + } = yield* agentAccessSettings(threadId); const capabilities = new Set< import("../mcp/McpInvocationContext.ts").McpCapability >(["orchestration", "worktree", "pull-requests"]); @@ -480,6 +498,9 @@ export const layerWithOptions = ( resolved.capabilities.has("preview") === browserToolsAvailable && resolved.capabilities.has("device") === deviceToolsAvailable ) { + // The credential stays; the user's tools are re-read on + // every prepare so a reopened process picks up an edit. + yield* mcpSessions.set({ ...existing, tools }); return { mcpCredentialId: existing.providerSessionId, issued: false }; } dropMcpCredentialReservation(threadId, existing.providerSessionId); @@ -491,7 +512,7 @@ export const layerWithOptions = ( browserToolsAvailable, capabilities, }); - yield* mcpSessions.set(credential.config); + yield* mcpSessions.set({ ...credential.config, tools }); reserveMcpCredential(threadId, credential.config.providerSessionId); return { mcpCredentialId: credential.config.providerSessionId, issued: true }; }), diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/opencode2_fork/opencode_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/opencode2_fork/opencode_transcript.ndjson index 57cbd14853460..d988be1e97791 100644 --- a/apps/server/src/orchestration-v2/testkit/fixtures/opencode2_fork/opencode_transcript.ndjson +++ b/apps/server/src/orchestration-v2/testkit/fixtures/opencode2_fork/opencode_transcript.ndjson @@ -47,7 +47,7 @@ {"type": "emit_inbound", "label": "message.list.response.2", "frame": {"type": "sdk.response", "operation": "message.list", "data": {"data": [], "cursor": {}}}} {"type": "expect_outbound", "label": "session.fork", "frame": {"type": "session.fork", "input": {"sessionID": "ses_f1484ea8affe5aTo8CcgbGIszj", "before": "msg_0eb7b1f9f001g95Bduh3bi8syS"}}} {"type": "emit_inbound", "label": "session.fork.response", "frame": {"type": "sdk.response", "operation": "session.fork", "data": {"data": {"id": "ses_f1484db83ffeLGtrRCFimo1H0e", "fork": {"sessionID": "ses_f1484ea8affe5aTo8CcgbGIszj", "boundary": {"type": "before", "messageID": "msg_0eb7b1f9f001g95Bduh3bi8syS"}}, "projectID": "global", "model": {"id": "big-pickle", "providerID": "opencode", "variant": "default"}, "cost": 0, "tokens": {"input": 0, "output": 0, "reasoning": 0, "cache": {"read": 0, "write": 0}}, "time": {"created": 1790657111165, "updated": 1790657111165}, "title": "spike fork (fork #1)", "location": {"directory": ""}, "permissions": [{"action": "*", "resource": "*", "effect": "allow"}, {"action": "subagent", "resource": "*", "effect": "deny"}]}}}} -{"type": "expect_outbound", "label": "session.update", "frame": {"type": "session.update", "input": {"sessionID": "ses_f1484db83ffeLGtrRCFimo1H0e", "permissions": [{"action": "*", "resource": "*", "effect": "allow"}, {"action": "t3-code-*", "resource": "*", "effect": "deny"}, {"action": "t3-code-thread_opencode2-fork_target_*", "resource": "*", "effect": "allow"}]}}} +{"type": "expect_outbound", "label": "session.update", "frame": {"type": "session.update", "input": {"sessionID": "ses_f1484db83ffeLGtrRCFimo1H0e", "permissions": [{"action": "*", "resource": "*", "effect": "allow"}, {"action": "t3-code-*", "resource": "*", "effect": "deny"}, {"action": "t3-code-thread_opencode2-fork_target_*", "resource": "*", "effect": "allow"}, {"action": "t3u-*", "resource": "*", "effect": "deny"}]}}} {"type": "emit_inbound", "label": "session.update.response", "frame": {"type": "sdk.response", "operation": "session.update", "data": null}} {"type": "emit_inbound", "label": "session.forked", "frame": {"type": "sdk.event", "event": {"id": "evt_0eb7b247d001fXzFroPg5P0bps", "created": 1790657111165, "type": "session.forked", "location": {"directory": ""}, "data": {"sessionID": "ses_f1484db83ffeLGtrRCFimo1H0e", "parentID": "ses_f1484ea8affe5aTo8CcgbGIszj", "boundary": {"type": "before", "messageID": "msg_0eb7b1f9f001g95Bduh3bi8syS"}, "instructions": {"core/environment": "db4a793a05fec32fdfa985a3432125a86d6cb42debc8b9ee8f6a99fbfcf2f93b", "core/date": "bf08b8486572ab3eef677a3c9ee12468e411ae41a8f4d2fb6cf02a6ca73f1986", "core/codemode": "616a7ad8b8e40e8a71eab238dfbbe9eaf0f4a9e6fdad853226d075bfe602e1e6", "core/skill-guidance": "0d001919496102654717308c72635523bf7c3cd99c81e058cc79f2947104f9a5"}, "instructionEntries": []}, "durable": {"aggregateID": "ses_f1484db83ffeLGtrRCFimo1H0e", "seq": 0, "version": 2}}}} {"type": "expect_outbound", "label": "session.update.title", "frame": {"type": "session.update", "input": {"sessionID": "ses_f1484db83ffeLGtrRCFimo1H0e", "title": ""}}} diff --git a/apps/server/src/orchestration-v2/testkit/fixtures/opencode2_switch/opencode_transcript.ndjson b/apps/server/src/orchestration-v2/testkit/fixtures/opencode2_switch/opencode_transcript.ndjson index ee2519419915a..f208396f5f914 100644 --- a/apps/server/src/orchestration-v2/testkit/fixtures/opencode2_switch/opencode_transcript.ndjson +++ b/apps/server/src/orchestration-v2/testkit/fixtures/opencode2_switch/opencode_transcript.ndjson @@ -53,7 +53,7 @@ {"type": "emit_inbound", "label": "session.execution.succeeded", "frame": {"type": "sdk.event", "event": {"id": "evt_0eb7eef75001z9Sy13uGDVqV3F", "created": 1790657359733, "type": "session.execution.succeeded", "data": {"sessionID": "ses_f14812197ffeCbw641wM2r3ZmP"}, "durable": {"aggregateID": "ses_f14812197ffeCbw641wM2r3ZmP", "seq": 15, "version": 1}}}} {"type": "expect_outbound", "label": "session.get", "frame": {"type": "session.get", "input": {"sessionID": "ses_f14812197ffeCbw641wM2r3ZmP"}}} {"type": "emit_inbound", "label": "session.get.response", "frame": {"type": "sdk.response", "operation": "session.get", "data": {"data": {"id": "ses_f14812197ffeCbw641wM2r3ZmP", "projectID": "global", "agent": "plan", "model": {"id": "big-pickle", "providerID": "opencode", "variant": "default"}, "cost": 0, "tokens": {"input": 8910, "output": 271, "reasoning": 0, "cache": {"read": 384, "write": 0}}, "outcome": "succeeded", "time": {"created": 1790657355410, "updated": 1790657355463}, "title": "spike switch", "location": {"directory": ""}, "permissions": [{"action": "*", "resource": "*", "effect": "allow"}, {"action": "subagent", "resource": "*", "effect": "deny"}]}}}} -{"type": "expect_outbound", "label": "session.update", "frame": {"type": "session.update", "input": {"sessionID": "ses_f14812197ffeCbw641wM2r3ZmP", "permissions": [{"action": "*", "resource": "*", "effect": "allow"}, {"action": "t3-code-*", "resource": "*", "effect": "deny"}, {"action": "t3-code-thread_opencode2_switch_*", "resource": "*", "effect": "allow"}]}}} +{"type": "expect_outbound", "label": "session.update", "frame": {"type": "session.update", "input": {"sessionID": "ses_f14812197ffeCbw641wM2r3ZmP", "permissions": [{"action": "*", "resource": "*", "effect": "allow"}, {"action": "t3-code-*", "resource": "*", "effect": "deny"}, {"action": "t3-code-thread_opencode2_switch_*", "resource": "*", "effect": "allow"}, {"action": "t3u-*", "resource": "*", "effect": "deny"}]}}} {"type": "emit_inbound", "label": "session.update.response", "frame": {"type": "sdk.response", "operation": "session.update", "data": null}} {"type": "expect_outbound", "label": "session.switchAgent.2", "frame": {"type": "session.switchAgent", "input": {"sessionID": "ses_f14812197ffeCbw641wM2r3ZmP", "agent": "build"}}} {"type": "emit_inbound", "label": "session.switchAgent.response.2", "frame": {"type": "sdk.response", "operation": "session.switchAgent", "data": null}} diff --git a/apps/server/src/provider/Drivers/AntigravityDriver.ts b/apps/server/src/provider/Drivers/AntigravityDriver.ts index 7a77aa6beb1ab..757e857216816 100644 --- a/apps/server/src/provider/Drivers/AntigravityDriver.ts +++ b/apps/server/src/provider/Drivers/AntigravityDriver.ts @@ -412,6 +412,7 @@ export const AntigravityDriver: ProviderDriver< ); const defaultModel = currentCatalog.pipe(Effect.map((catalog) => catalog?.defaultChatModel)); const orchestrationAdapter = yield* makeAntigravityAdapterV2({ + environment: processEnvironment, instanceId, selfInvocation, makeRuntime, diff --git a/packages/provider-acp-registry/src/server/adapter.ts b/packages/provider-acp-registry/src/server/adapter.ts index 63157b164624c..a4e4af2e01c97 100644 --- a/packages/provider-acp-registry/src/server/adapter.ts +++ b/packages/provider-acp-registry/src/server/adapter.ts @@ -241,6 +241,7 @@ export const makeAcpRegistryAdapterV2 = Effect.fn("makeAcpRegistryAdapterV2")(fu ...(options.assertComplete === undefined ? {} : { assertComplete: options.assertComplete }), }; return yield* makeAcpAdapterV2({ + environment: options.environment, instanceId: options.instanceId, flavor, selfInvocation: options.selfInvocation, diff --git a/packages/provider-acp/src/server/AcpSessionRuntime.ts b/packages/provider-acp/src/server/AcpSessionRuntime.ts index 8f40efd164fad..551ae885f8e9b 100644 --- a/packages/provider-acp/src/server/AcpSessionRuntime.ts +++ b/packages/provider-acp/src/server/AcpSessionRuntime.ts @@ -2110,14 +2110,17 @@ export const make = ( initializeResult: EffectAcpSchema.InitializeResponse, activationOptions?: AcpSessionActivationOptions, ): ReadonlyArray => { + const capabilities = initializeResult.agentCapabilities?.mcpCapabilities; const acpServers = activationOptions?.acpMcpServers ?? options.acpMcpServers ?? []; - if ( - initializeResult.agentCapabilities?.mcpCapabilities?.acp === true && - acpServers.length > 0 - ) { - return acpServers; - } - return activationOptions?.mcpServers ?? options.mcpServers ?? []; + const selected = + capabilities?.acp === true && acpServers.length > 0 + ? acpServers + : (activationOptions?.mcpServers ?? options.mcpServers ?? []); + // Stdio is the only transport every agent must accept; an agent that + // does not advertise http rejects the whole session over one entry. + return capabilities?.http === true + ? selected + : selected.filter((server) => !("type" in server) || server.type !== "http"); }; const startOnce = Effect.gen(function* () { diff --git a/packages/provider-acp/src/server/adapter.ts b/packages/provider-acp/src/server/adapter.ts index e65c2fea6119b..0b7d73e095a1e 100644 --- a/packages/provider-acp/src/server/adapter.ts +++ b/packages/provider-acp/src/server/adapter.ts @@ -27,6 +27,8 @@ import { type ProviderRequestKind, type ProviderThreadId, type ProviderUserInputAnswers, + mcpServerVariableRecord, + type ResolvedMcpServer, type RuntimeRequestId, type ThreadTokenUsageSnapshot, type ThreadId, @@ -34,6 +36,8 @@ import { import { AgentScope, AgentScopeThreadId } from "@t3tools/shared/AgentScope"; import { modelSelectionsEqual } from "@t3tools/shared/model"; import { type SelfInvocation, selfInvocationArgs } from "@t3tools/shared/nodeRuntime"; +import * as HostProcess from "@t3tools/shared/HostProcess"; +import { SpawnExecutableResolution } from "@t3tools/shared/shell"; import { FILE_HEADERS_ONLY, formatPatch, structuredPatch } from "diff"; import * as Cause from "effect/Cause"; import * as Crypto from "effect/Crypto"; @@ -363,6 +367,7 @@ export interface AcpAdapterV2SubagentUpdate { } export interface AcpAdapterV2Options { + readonly environment?: NodeJS.ProcessEnv; readonly instanceId: ProviderInstanceId; readonly flavor: AcpAdapterV2Flavor; readonly selfInvocation: SelfInvocation; @@ -541,17 +546,56 @@ interface AcpMcpContext { readonly authorization?: string; } +/** + * The user's servers from Settings → Tools, passed through as plain ACP + * entries. ACP wants an absolute command, so a bare name such as `npx` is + * looked up on the PATH the agent inherits; one that cannot be found is sent + * as typed. Http entries are dropped later for agents that do not advertise + * http support. + */ +function acpUserMcpServers( + servers: ReadonlyArray, + resolveCommand: (command: string) => string, +): ReadonlyArray { + return servers.map((server) => + server.transport.type === "stdio" + ? { + // Untyped like T3's own entry: the shape every ACP version accepts. + name: server.name, + command: resolveCommand(server.transport.command), + args: [...server.transport.args], + env: Object.entries(mcpServerVariableRecord(server.transport.env)).map( + ([name, value]) => ({ name, value }), + ), + } + : { + type: "http" as const, + name: server.name, + url: server.transport.url, + headers: Object.entries(mcpServerVariableRecord(server.transport.headers)).map( + ([name, value]) => ({ name, value }), + ), + }, + ); +} + function acpMcpContext( session: McpProviderSession.McpProviderSessionConfig | undefined, self: SelfInvocation, + resolveCommand: (command: string) => string = (command) => command, ): AcpMcpContext { if (session === undefined) { return { servers: [], acpServers: [] }; } - // Agents that advertise optional http support still routinely fail to wire - // injected http servers through to their backend (codex-acp 1.2.0 and pi-acp - // both drop them), so every ACP session gets the `t3 acp-mcp-bridge` stdio - // server, which forwards JSON-RPC to T3's authenticated MCP endpoint. + // Both lists carry them: an agent that takes T3's server over ACP gets + // only `acpServers`, so the user's servers would otherwise be lost. + const userServers = acpUserMcpServers(session.tools?.servers ?? [], resolveCommand); + // Stdio is ACP's required baseline MCP transport. Agents that advertise + // optional http support still routinely fail to wire injected http servers + // through to their backend (codex-acp 1.2.0 and pi-acp both drop them), so + // every ACP session gets the `t3 acp-mcp-bridge` stdio server, which + // forwards JSON-RPC to T3's authenticated MCP endpoint. The credential + // travels via environment variables, never the command line. return { servers: [ { @@ -564,8 +608,9 @@ function acpMcpContext( { name: "T3_ACP_MCP_AUTHORIZATION", value: session.authorizationHeader }, ], }, + ...userServers, ], - acpServers: [{ type: "acp", name: "t3-code", serverId: "t3-code" }], + acpServers: [{ type: "acp", name: "t3-code", serverId: "t3-code" }, ...userServers], endpoint: session.endpoint, authorization: session.authorizationHeader, processEnvironment: { @@ -1287,10 +1332,18 @@ export const makeAcpAdapterV2 = Effect.fn("makeAcpAdapterV2")(function* ( const host = yield* ProviderHost.ProviderHost; const mcpSessions = yield* McpProviderSessions.McpProviderSessions; const { flavor, selfInvocation: self } = options; + const resolveExecutable = yield* SpawnExecutableResolution; + const hostPlatform = yield* HostProcess.Platform; + const hostEnvironment = yield* HostProcess.Environment; + const resolveCommand = (command: string) => + resolveExecutable(command, hostPlatform, { ...hostEnvironment, ...options.environment }) ?? + command; const readMcpContext = (threadId: ThreadId | null) => threadId === null ? Effect.succeed(acpMcpContext(undefined, self)) - : mcpSessions.read(threadId).pipe(Effect.map((session) => acpMcpContext(session, self))); + : mcpSessions + .read(threadId) + .pipe(Effect.map((session) => acpMcpContext(session, self, resolveCommand))); const driver = flavor.driver; const continuationRequests = options.continuationRequests; const postSettleContinuationEnabled = diff --git a/packages/provider-core/src/server/mcpSession.ts b/packages/provider-core/src/server/mcpSession.ts index 8a42ced557684..da748ccd5e0b5 100644 --- a/packages/provider-core/src/server/mcpSession.ts +++ b/packages/provider-core/src/server/mcpSession.ts @@ -1,4 +1,32 @@ -import type { EnvironmentId, ProviderInstanceId, ThreadId } from "@t3tools/contracts"; +import type { + EnvironmentId, + ProviderInstanceId, + ResolvedMcpServer, + ThreadId, +} from "@t3tools/contracts"; + +/** + * The user's tools for one thread, resolved from Settings → Tools when the + * session is prepared. Adapters add the servers next to `t3-code` and hide + * the skills where their provider can. + */ +export interface McpProviderSessionTools { + /** Enabled servers with secrets materialized, sorted by name. */ + readonly servers: ReadonlyArray; + /** Skill names hidden from the agent, sorted. */ + readonly disabledSkills: ReadonlyArray; + /** + * Changes whenever `servers` or `disabledSkills` do, without exposing a + * secret. Adapters compare it to decide when a live process is stale. + */ + readonly fingerprint: string; +} + +export const EMPTY_MCP_PROVIDER_SESSION_TOOLS: McpProviderSessionTools = { + servers: [], + disabledSkills: [], + fingerprint: "", +}; export interface McpProviderSessionConfig { readonly environmentId: EnvironmentId; @@ -15,6 +43,8 @@ export interface McpProviderSessionConfig { readonly browserToolsAvailable: boolean; readonly capabilities?: ReadonlySet; readonly agentDeviceEnvironment?: Readonly>; + /** Servers and skill switches from Settings → Tools; absent means none. */ + readonly tools?: McpProviderSessionTools; } export function withAgentDeviceEnvironment( diff --git a/packages/provider-cursor/src/server/adapter.ts b/packages/provider-cursor/src/server/adapter.ts index ae495016e9ff9..a70f7cde3d5ef 100644 --- a/packages/provider-cursor/src/server/adapter.ts +++ b/packages/provider-cursor/src/server/adapter.ts @@ -26,6 +26,7 @@ import { type OrchestrationV2ProviderTurn, type OrchestrationV2Subagent, type OrchestrationV2TurnItem, + mcpServerVariableRecord, type ProviderInstanceId, type ThreadId, } from "@t3tools/contracts"; @@ -208,7 +209,25 @@ export function cursorMcpServers( if (session === undefined) { return undefined; } + const servers = session.tools?.servers ?? []; return { + ...Object.fromEntries( + servers.map((server): [string, McpServerConfig] => [ + server.name, + server.transport.type === "stdio" + ? { + type: "stdio", + command: server.transport.command, + args: [...server.transport.args], + env: mcpServerVariableRecord(server.transport.env), + } + : { + type: "http", + url: server.transport.url, + headers: mcpServerVariableRecord(server.transport.headers), + }, + ]), + ), "t3-code": { type: "http", url: session.endpoint, diff --git a/packages/provider-grok/src/server/adapter.ts b/packages/provider-grok/src/server/adapter.ts index 19f1d28c5e851..a6d093ce4733d 100644 --- a/packages/provider-grok/src/server/adapter.ts +++ b/packages/provider-grok/src/server/adapter.ts @@ -336,6 +336,7 @@ export const makeGrokAdapterV2 = Effect.fn("makeGrokAdapterV2")(function* ( options: GrokAdapterV2Options, ) { return yield* makeAcpAdapterV2({ + environment: options.environment, instanceId: options.instanceId, flavor: makeGrokAcpAdapterFlavor(options, yield* HostProcess.HomeDirectory), selfInvocation: options.selfInvocation, diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index 71144f24dd70c..27a0bbdd5eacf 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -33,6 +33,7 @@ import { type ProviderInstanceId, type ProviderRequestKind, type ProviderSessionId, + mcpServerVariableRecord, type RuntimeRequestId, type ThreadId, } from "@t3tools/contracts"; @@ -605,6 +606,20 @@ const OPENCODE_RESTRICTED_PERMISSIONS = [ */ export function openCodePermissionRules( runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy, + disabledSkills: ReadonlyArray = [], +): PermissionRuleset { + // Skills switched off in Settings → Tools; the last matching rule wins, so + // these follow every allow below. + const skillRules = disabledSkills.map((name) => ({ + permission: "skill", + pattern: name, + action: "deny" as const, + })); + return [...openCodeRuntimePermissionRules(runtimePolicy), ...skillRules]; +} + +function openCodeRuntimePermissionRules( + runtimePolicy: ProviderAdapter.ProviderAdapterV2RuntimePolicy, ): PermissionRuleset { const sandboxPolicy = recordValue(runtimePolicy, "sandboxPolicy"); const sandboxType = recordString(sandboxPolicy, "type"); @@ -962,15 +977,50 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function const orchestrationSystemPrompt = t3OrchestrationSystemPrompt(hasT3Mcp); if (hasT3Mcp) { yield* OpenCodeRuntime.runOpenCodeSdk("mcp.add", () => - client.mcp.add({ - name: "t3-code", - config: { - type: "remote", - url: mcpSession.endpoint, - headers: { Authorization: mcpSession.authorizationHeader }, - oauth: false, + client.mcp.add( + { + name: "t3-code", + config: { + type: "remote", + url: mcpSession.endpoint, + headers: { Authorization: mcpSession.authorizationHeader }, + oauth: false, + }, }, - }), + { throwOnError: true }, + ), + ); + } + // The user's servers are additions that do not need to reach T3, so + // an external server gets them too. One that fails to register must + // not stop the session, so each logs and moves on. + for (const server of mcpSession?.tools?.servers ?? []) { + yield* OpenCodeRuntime.runOpenCodeSdk("mcp.add", () => + client.mcp.add( + { + name: server.name, + config: + server.transport.type === "stdio" + ? { + type: "local", + command: [server.transport.command, ...server.transport.args], + environment: mcpServerVariableRecord(server.transport.env), + } + : { + type: "remote", + url: server.transport.url, + headers: mcpServerVariableRecord(server.transport.headers), + }, + }, + { throwOnError: true }, + ), + ).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Could not add an MCP server to OpenCode.", { + server: server.name, + cause, + }), + ), ); } @@ -3003,16 +3053,22 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function if (threadInput.existingProviderThread?.nativeThreadRef != null) { return yield* runtimeSession.resumeThread({ providerThread: threadInput.existingProviderThread, + threadId: threadInput.threadId, + runtimePolicy: threadInput.runtimePolicy, }); } // No title: OpenCode generates one from the first prompt only when // session.create leaves it unset (SessionPrompt.ensureTitle). + const disabledSkills = + (yield* mcpSessions.read(threadInput.threadId))?.tools?.disabledSkills ?? []; const response = yield* sdkCall( "session.create", - { permission: openCodePermissionRules(threadInput.runtimePolicy) }, + { + permission: openCodePermissionRules(threadInput.runtimePolicy, disabledSkills), + }, () => client.session.create({ - permission: openCodePermissionRules(threadInput.runtimePolicy), + permission: openCodePermissionRules(threadInput.runtimePolicy, disabledSkills), }), ); const nativeSession = unwrapData("session.create", response); @@ -3056,6 +3112,24 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function client.session.get({ sessionID: sessionId }), ); const nativeSession = unwrapData("session.get", response); + // The saved rules may predate a skill switched off since; a + // resume that knows its policy brings them up to date. + const appThreadId = threadInput.threadId ?? threadInput.providerThread.appThreadId; + if (threadInput.runtimePolicy !== undefined && appThreadId !== null) { + const permission = openCodePermissionRules( + threadInput.runtimePolicy, + (yield* mcpSessions.read(appThreadId))?.tools?.disabledSkills ?? [], + ); + const saved = nativeSession.permission ?? []; + const unchanged = + saved.length === permission.length && + saved.every((rule, index) => permissionRuleEquals(rule, permission[index]!)); + if (!unchanged) { + yield* sdkCall("session.update", { sessionID: sessionId, permission }, () => + client.session.update({ sessionID: sessionId, permission }), + ); + } + } const resumedAt = yield* DateTime.now; const providerThread = { ...threadInput.providerThread, @@ -3560,10 +3634,16 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function return yield* protocolError( "OpenCode did not preserve the requested rewind boundary.", ); + // The fork replaces the session, so it needs the skill rules too. + const appThreadId = rollbackInput.providerThread.appThreadId; + const disabledSkills = + appThreadId === null + ? [] + : ((yield* mcpSessions.read(appThreadId))?.tools?.disabledSkills ?? []); yield* sdkCall("session.update", { sessionID: fork.id }, () => client.session.update({ sessionID: fork.id, - permission: openCodePermissionRules(input.runtimePolicy), + permission: openCodePermissionRules(input.runtimePolicy, disabledSkills), }), ); retainedThread = { diff --git a/packages/provider-opencode/src/server/v2/adapter.ts b/packages/provider-opencode/src/server/v2/adapter.ts index 17214ae2116db..b14189db20e95 100644 --- a/packages/provider-opencode/src/server/v2/adapter.ts +++ b/packages/provider-opencode/src/server/v2/adapter.ts @@ -28,9 +28,11 @@ import { type MessageId, type ModelSelection, type ProviderApprovalDecision, + mcpServerVariableRecord, type ProviderInstanceId, type RunId, type RuntimeRequestId, + ThreadId, } from "@t3tools/contracts"; import type * as Cause from "effect/Cause"; import * as DateTime from "effect/DateTime"; @@ -51,6 +53,7 @@ import * as ProviderHost from "@t3tools/provider-core/server/ProviderHost"; import * as OpenCode2Client from "./OpenCode2Client.ts"; import * as OpenCode2Server from "./OpenCode2Server.ts"; import * as OpenCodeRuntime from "../OpenCodeRuntime.ts"; +import * as McpProviderSession from "@t3tools/provider-core/server/mcpSession"; import * as McpProviderSessions from "@t3tools/provider-core/server/McpProviderSessions"; import { buildRuntimeInstructions } from "@t3tools/provider-core/server/runtimeInstructions"; import { t3OrchestrationSystemPrompt } from "@t3tools/provider-core/server/orchestrationInstructions"; @@ -303,9 +306,17 @@ interface ThreadState { mcp: | { readonly name: string; readonly directory: string; readonly credential: string } | undefined; + /** The user's servers from Settings → Tools as registered for this thread. */ + userMcp: UserMcpRegistration | undefined; instructions: string | undefined; } +interface UserMcpRegistration { + readonly names: ReadonlyArray; + readonly directory: string; + readonly fingerprint: string; +} + type TurnTerminal = | { readonly status: "completed" | "interrupted" } | { readonly status: "failed"; readonly failure: ReturnType }; @@ -353,24 +364,51 @@ export const t3McpServerName = Effect.fn("t3McpServerName")(function* (threadId: return `t3-code-${Hex.encode(digest).slice(0, 16)}`; }); +/** + * The user's servers are registered per directory like T3's own, so each + * thread registers its own copies under `t3u--` (at most + * 61 characters, under OpenCode's 64) and its rules allow only those. + */ +const userMcpServerPrefix = Effect.fn("userMcpServerPrefix")(function* (threadId: string) { + const crypto = yield* Crypto.Crypto; + const digest = yield* crypto + .digest("SHA-256", new TextEncoder().encode(threadId)) + .pipe(Effect.orDie); + return `t3u-${Hex.encode(digest).slice(0, 8)}`; +}); + /** * The rules that keep T3's MCP servers to their own thread, after the mode's: * the last matching rule wins, so every thread's T3 server is denied and then * this thread's own is allowed again, in every mode. */ -const mcpRules = (mcpServerName: string | null): ReadonlyArray => - mcpServerName === null +const mcpRules = ( + mcpServerName: string | null, + userMcpPrefix: string | null = null, + userEffect: Rule["effect"] = "ask", +): ReadonlyArray => [ + ...(mcpServerName === null ? [] : [ - { action: "t3-code-*", resource: "*", effect: "deny" }, - { action: `${mcpServerName}_*`, resource: "*", effect: "allow" }, - ]; + { action: "t3-code-*", resource: "*", effect: "deny" as const }, + { action: `${mcpServerName}_*`, resource: "*", effect: "allow" as const }, + ]), + // Registrations are shared per directory, so another thread's user servers + // are denied even when this thread has none of its own. + ...(mcpServerName === null && userMcpPrefix === null + ? [] + : [{ action: "t3u-*", resource: "*", effect: "deny" as const }]), + ...(userMcpPrefix === null + ? [] + : [{ action: `${userMcpPrefix}-*`, resource: "*", effect: userEffect }]), +]; const sessionRules = ( policy: RulesPolicy, paths: ReadonlyArray, grants: ReadonlyArray, mcpServerName: string | null, + userMcpPrefix: string | null = null, ): ReadonlyArray => [ ...(policy.runtimeMode === "full-access" ? [rule("*", "allow")] @@ -384,7 +422,10 @@ const sessionRules = ( // are never denied: the free tier refuses sessions whose rules deny them. ...(policy.interactionMode === "plan" ? [rule("edit", "deny")] : []), ...paths, - ...mcpRules(mcpServerName), + ...mcpRules(mcpServerName, userMcpPrefix, policy.runtimeMode === "full-access" ? "allow" : "ask"), + ...grants.filter( + (entry) => userMcpPrefix !== null && entry.action.startsWith(`${userMcpPrefix}-`), + ), ]; const sameRules = (left: ReadonlyArray | undefined, right: ReadonlyArray) => @@ -670,6 +711,8 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr const driver = OPENCODE_PROVIDER; const mcpServerNameFor = (threadId: string) => t3McpServerName(threadId).pipe(Effect.provideService(Crypto.Crypto, crypto)); + const userMcpPrefixFor = (threadId: string) => + userMcpServerPrefix(threadId).pipe(Effect.provideService(Crypto.Crypto, crypto)); const borrow = Effect.gen(function* () { const lent = yield* Deferred.make< @@ -769,6 +812,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr stoppedChildren: new Set(), strandedSteers: new Set(), mcp: undefined, + userMcp: undefined, instructions: undefined, }); @@ -2556,12 +2600,18 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr return { next, stream: yield* next.events }; }).pipe(Effect.onError(() => Scope.close(scope, Exit.void))); const previous = currentScope; + const serverChanged = connection.url !== next.url; connection = next; client = next.client; + if (serverChanged) { + for (const state of threads.values()) state.userMcp = undefined; + } currentScope = scope; yield* Scope.close(previous, Exit.void); - // A restarted server forgot T3's MCP servers; the next turn adds them again. - for (const state of threads.values()) state.mcp = undefined; + // Keep registrations across a stream reconnect; identical adds restore an evicted location. + for (const state of threads.values()) { + state.mcp = undefined; + } yield* lock.withPermit(reconcile).pipe(Effect.timeout(RECONCILE_TIMEOUT)); return stream; }).pipe( @@ -2691,11 +2741,16 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr policy.runtimeMode === "full-access" && !plan ? [] : yield* pathsFor(thread.directory, plan ? [thread.agent, "plan"] : [thread.agent]); + // Only a thread with servers of its own gets the allow rule for them. + const hasUserMcp = + appThreadId !== null && + ((yield* mcpSessions.read(ThreadId.make(appThreadId)))?.tools?.servers.length ?? 0) > 0; return sessionRules( policy, paths, policy.runtimeMode === "full-access" ? [] : thread.grants, appThreadId === null ? null : yield* mcpServerNameFor(appThreadId), + hasUserMcp ? yield* userMcpPrefixFor(appThreadId) : null, ); }); @@ -2925,14 +2980,118 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr client.mcp.remove({ server: mcp.name, location: { directory: mcp.directory } }), ).pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: true })); + const removeUserMcp = (registration: UserMcpRegistration) => + Effect.forEach( + registration.names, + (name) => removeMcp({ name, directory: registration.directory }), + { concurrency: 8, discard: true }, + ); + + // T3's MCP registrations outlive a session only on an external server; a + // spawned one forgets them when it stops. yield* Effect.addFinalizer(() => Effect.forEach( - [...threads.values()].flatMap((state) => (state.mcp === undefined ? [] : [state.mcp])), + [...threads.values()].flatMap((state) => [ + ...(state.mcp === undefined ? [] : [state.mcp]), + ...(state.userMcp === undefined + ? [] + : state.userMcp.names.map((name) => ({ + name, + directory: state.userMcp!.directory, + }))), + ]), removeMcp, { concurrency: 8, discard: true }, ), ); + /** + * Registers the thread's servers from Settings → Tools, replacing the + * previous set when the directory or the settings changed. Each server is + * optional: one OpenCode rejects is logged and the turn still runs. + */ + const prepareUserMcp = Effect.fnUntraced(function* ( + state: ThreadState, + threadId: ThreadId, + directory: string, + mcpSession: McpProviderSession.McpProviderSessionConfig | undefined, + ) { + // Unlike T3's own endpoint, the user's servers do not depend on reaching + // T3, so an external OpenCode server gets them too. + const tools = mcpSession?.tools ?? McpProviderSession.EMPTY_MCP_PROVIDER_SESSION_TOOLS; + const current = state.userMcp; + const unchanged = + current !== undefined && + current.directory === directory && + current.fingerprint === tools.fingerprint; + if (current !== undefined && !unchanged) { + yield* removeUserMcp(current); + state.userMcp = undefined; + } + if (tools.servers.length === 0) return; + const prefix = yield* userMcpPrefixFor(threadId); + const inventory = unchanged + ? yield* client.mcp.list({ location: { directory } }).pipe( + Effect.timeout(INVENTORY_TIMEOUT), + Effect.map( + (listed) => + new Set( + listed.data + .filter((entry) => entry.status.status !== "failed") + .map((entry) => entry.name), + ), + ), + Effect.orElseSucceed(() => new Set(current.names)), + ) + : new Set(); + const names = unchanged ? current.names.filter((name) => inventory.has(name)) : []; + for (const server of tools.servers) { + const name = `${prefix}-${server.name}`; + if (names.includes(name)) continue; + const added = yield* client.mcp + .add({ + server: name, + location: { directory }, + config: + server.transport.type === "stdio" + ? new Mcp.LocalConfig({ + type: "local", + command: [server.transport.command, ...server.transport.args], + environment: mcpServerVariableRecord(server.transport.env), + }) + : new Mcp.RemoteConfig({ + type: "remote", + url: server.transport.url, + headers: mcpServerVariableRecord(server.transport.headers), + }), + }) + .pipe( + Effect.timeout(INVENTORY_TIMEOUT), + Effect.as(true), + Effect.catchCause((cause) => + Effect.logWarning("Could not add an MCP server to OpenCode.", { + server: server.name, + cause, + }).pipe(Effect.as(false)), + ), + ); + if (added) names.push(name); + } + state.userMcp = { + names, + directory, + fingerprint: tools.fingerprint, + }; + }); + + /** + * T3's MCP server for this thread, and the per-turn instructions. The MCP + * server is registered for the session's directory under the thread's own + * name and credential (the session rules allow only it), and removed when + * the thread unloads or the session closes. OpenCode 2 has no per-prompt + * system field, so the instructions are a session instructions entry, + * which applies from the next step; it is only rewritten when it changes. + */ const prepareTurn = Effect.fnUntraced(function* ( sessionId: string, state: ThreadState, @@ -2981,6 +3140,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr ); if (mcpAvailable) state.mcp = wanted; } + yield* prepareUserMcp(state, turnInput.threadId, directory, mcpSession); const instructions = [ buildRuntimeInstructions({ harness: "OpenCode", model: turnInput.modelSelection.model }), t3OrchestrationSystemPrompt(mcpAvailable), @@ -3697,6 +3857,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr threads.delete(child); } if (state.mcp !== undefined) yield* removeMcp(state.mcp); + if (state.userMcp !== undefined) yield* removeUserMcp(state.userMcp); }), respondToRuntimeRequest: (requestInput) => Effect.gen(function* () { From b8e07abe42b14681e1bbe92a64bc5235faddbf9f Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 16:02:06 +0000 Subject: [PATCH 2/9] fix(providers): retain project tool overrides and protect external OpenCode config --- .../ProviderSessionManager.test.ts | 17 +++++ .../ProviderSessionManager.ts | 2 +- .../src/server/adapter.test.ts | 63 +++++++++++++++++++ .../provider-opencode/src/server/adapter.ts | 7 +-- 4 files changed, 84 insertions(+), 5 deletions(-) diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts index f37b648e5b8ed..1bb4a7e98492f 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts @@ -636,6 +636,7 @@ function runBrowserAccessScenario(input: { readonly deviceOverride?: boolean; readonly createThread?: boolean; readonly projectExists?: boolean; + readonly toolsOverride?: boolean; }) { return Effect.gen(function* () { const state = yield* Ref.make(emptyState); @@ -679,9 +680,22 @@ function runBrowserAccessScenario(input: { projectServiceLayer: layerProjectService, serverSettingsLayer: ServerSettings.layerTest({ enableAgentBrowserAccess: input.enableAgentBrowserAccess, + ...(input.toolsOverride + ? { + mcpServers: { + docs: { + enabled: true, + transport: { type: "http", url: "https://example.com/mcp", headers: [] }, + }, + }, + } + : {}), projectSettingsOverrides: { [projectId]: { enableAgentBrowserAccess: input.projectOverride, + ...(input.toolsOverride + ? { mcpServers: { docs: { enabled: false } }, disabledSkills: { review: true } } + : {}), ...(input.deviceOverride === undefined ? {} : { enableAgentDeviceAccess: input.deviceOverride }), @@ -2000,9 +2014,12 @@ it.effect("ProviderSessionManagerV2 fails browser access closed for a missing pr enableAgentBrowserAccess: true, projectOverride: true, projectExists: false, + toolsOverride: true, }); assert.isDefined(captured); assert.equal(captured?.browserToolsAvailable, false); + assert.deepEqual(captured?.tools?.servers, []); + assert.deepEqual(captured?.tools?.disabledSkills, ["review"]); }), ); diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.ts index ee26cabef464a..adecdd3f36649 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.ts @@ -357,7 +357,7 @@ export const layerWithOptions = ( return { browser: browserOverridden ? false : settings.enableAgentBrowserAccess, device: deviceOverridden ? false : settings.enableAgentDeviceAccess, - tools: resolveAgentTools(settings, null), + tools: resolveAgentTools(settings, thread.projectId), }; } const effective = resolveProjectSettings(settings, thread.projectId).settings; diff --git a/packages/provider-opencode/src/server/adapter.test.ts b/packages/provider-opencode/src/server/adapter.test.ts index 72348b98aa779..4308aec389187 100644 --- a/packages/provider-opencode/src/server/adapter.test.ts +++ b/packages/provider-opencode/src/server/adapter.test.ts @@ -3,6 +3,7 @@ import * as NodeServices from "@effect/platform-node/NodeServices"; import type { OpencodeClient, ToolPart } from "@opencode-ai/sdk/v2"; import { CheckpointId, + EnvironmentId, NodeId, ProjectId, ProviderInstanceId, @@ -539,6 +540,68 @@ describe("OpenCodeAdapterV2", () => { ), ); + it.effect("leaves external MCP configuration untouched through add, disable and reopen", () => + Effect.gen(function* () { + const sessions = yield* McpProviderSessions.McpProviderSessions; + const threadId = ThreadId.make("thread-opencode-external-tools"); + const nativeConfig = { type: "remote", url: "https://native.example/mcp" }; + const registry = new Map([["native", nativeConfig]]); + const added: string[] = []; + const injected = { + name: "docs", + transport: { + type: "http" as const, + url: "https://tools.example/mcp", + headers: [{ name: "Authorization", value: "must-not-retain", sensitive: true }], + }, + }; + const client = { + event: { + subscribe: async (_input: unknown, options: { signal: AbortSignal }) => { + const events = asyncEventStream(); + options.signal.addEventListener("abort", () => events.close()); + return { stream: events.stream }; + }, + }, + session: { + create: async () => ({ data: { id: "root", time: { created: 1, updated: 1 } } }), + abort: async () => ({ data: true }), + children: async () => ({ data: [] }), + }, + mcp: { + add: async ({ name, config }: { name: string; config: typeof nativeConfig }) => { + added.push(name); + registry.set(name, config); + return { data: Object.fromEntries(registry) }; + }, + }, + }; + for (const servers of [[injected], [], []]) { + yield* sessions.set({ + environmentId: EnvironmentId.make("test"), + threadId, + providerInstanceId: ProviderInstanceId.make("opencode-external-tools"), + providerSessionId: "external-tools", + endpoint: "https://t3.example/mcp", + authorizationHeader: "Bearer test", + browserToolsAvailable: false, + tools: { servers, disabledSkills: [], fingerprint: String(servers.length) }, + }); + const scope = yield* Scope.make(); + yield* makeOpenCodeRuntimeHarness("external-tools", "root", client).pipe( + Effect.provideService(Scope.Scope, scope), + ); + yield* Scope.close(scope, Exit.void); + assert.isFalse(registry.has("docs")); + assert.deepEqual(Array.from(registry), [["native", nativeConfig]]); + } + assert.deepEqual(added, []); + }).pipe( + Effect.provide(Layer.merge(IdAllocator.layer, McpProviderSessions.layer)), + Effect.scoped, + ), + ); + it.effect("aborts external root and descendants before closing the event stream", () => Effect.gen(function* () { const scope = yield* Scope.make(); diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index 27a0bbdd5eacf..2f50b29b3dc8f 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -991,10 +991,9 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function ), ); } - // The user's servers are additions that do not need to reach T3, so - // an external server gets them too. One that fails to register must - // not stop the session, so each logs and moves on. - for (const server of mcpSession?.tools?.servers ?? []) { + // OpenCode 1 cannot remove dynamic configuration. An external server + // outlives this session, so injecting here would retain revoked credentials. + for (const server of connection.external ? [] : (mcpSession?.tools?.servers ?? [])) { yield* OpenCodeRuntime.runOpenCodeSdk("mcp.add", () => client.mcp.add( { From 65b04399cf29f4b7183e4fdeb36eab000f0e5732 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 16:26:23 +0000 Subject: [PATCH 3/9] fix(codex): redact MCP credentials in protocol logs --- .../Adapters/CodexAdapterV2.test.ts | 82 +++++++++++++++++++ .../Adapters/CodexAdapterV2.ts | 20 ++++- 2 files changed, 98 insertions(+), 4 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts index d05d4ef3357c7..6ecc2cb3365ac 100644 --- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.test.ts @@ -1164,6 +1164,88 @@ describe("CodexAdapterV2 native protocol logging", () => { }, }, }); + + const params = CodexAdapterV2.codexThreadRuntimeParams({ + mcpSession: { + environmentId: EnvironmentId.make("environment-logger"), + threadId, + providerSessionId: "mcp-session-logger", + providerInstanceId: ProviderInstanceId.make("codex"), + endpoint: "http://127.0.0.1:43123/mcp", + authorizationHeader: "Bearer t3-token", + browserToolsAvailable: false, + tools: { + servers: [ + { + name: "local", + transport: { + type: "stdio", + command: "node", + args: ["mcp.js"], + env: [ + { name: "AWS_SECRET_ACCESS_KEY", value: "aws-credential", sensitive: true }, + { name: "DATABASE_URL", value: "database-credential", sensitive: true }, + { name: "PRIVATE_KEY", value: "private-credential", sensitive: true }, + ], + }, + }, + { + name: "remote", + transport: { + type: "http", + url: "https://example.com/mcp", + headers: [ + { name: "X-Auth-Key", value: "header-credential", sensitive: true }, + { name: "Cookie", value: "cookie-credential", sensitive: true }, + ], + }, + }, + ], + disabledSkills: [], + fingerprint: "logger-tools", + }, + }, + }); + const redactedServers = { + local: { + command: "node", + args: ["mcp.js"], + env: { + AWS_SECRET_ACCESS_KEY: "[REDACTED]", + DATABASE_URL: "[REDACTED]", + PRIVATE_KEY: "[REDACTED]", + }, + }, + remote: { + url: "https://example.com/mcp", + http_headers: { "X-Auth-Key": "[REDACTED]", Cookie: "[REDACTED]" }, + }, + "t3-code": { + url: "http://127.0.0.1:43123/mcp", + tool_timeout_sec: 3_900, + http_headers: { Authorization: "[REDACTED]" }, + }, + }; + for (const method of ["thread/start", "thread/resume"]) { + yield* protocolLogger({ + direction: "outgoing", + stage: "decoded", + payload: { method, params, configJson: JSON.stringify(params.config) }, + }); + const logged = writes.at(-1)?.event; + assert.nestedPropertyVal(logged, "event.payload.method", method); + assert.deepNestedPropertyVal( + logged, + "event.payload.params.config.mcp_servers", + redactedServers, + ); + assert.deepNestedPropertyVal( + logged, + "event.payload.configJson", + JSON.stringify({ ...params.config, mcp_servers: redactedServers }), + ); + } + assert.equal(writes.length, 3); }), ); diff --git a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts index 6332c2d6af507..6760f73fafbd0 100644 --- a/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/CodexAdapterV2.ts @@ -1481,9 +1481,9 @@ export function makeCodexAppServerProtocolLogger(input: { }; } -function redactCodexProtocolValue(value: unknown): unknown { +function redactCodexProtocolValue(value: unknown, context?: "mcp" | "values"): unknown { if (Array.isArray(value)) { - return value.map(redactCodexProtocolValue); + return value.map((nested) => redactCodexProtocolValue(nested, context)); } if (value === null || typeof value !== "object") { if (typeof value !== "string") { @@ -1503,7 +1503,10 @@ function redactCodexProtocolValue(value: unknown): unknown { } try { return JSON.stringify( - redactCodexProtocolValue(boundProviderEventForLogging(JSON.parse(trimmed) as unknown)), + redactCodexProtocolValue( + boundProviderEventForLogging(JSON.parse(trimmed) as unknown), + context, + ), ); } catch { return value; @@ -1512,7 +1515,16 @@ function redactCodexProtocolValue(value: unknown): unknown { return Object.fromEntries( Object.entries(value).map(([key, nested]) => [ key, - isSensitiveCodexProtocolKey(key) ? "[REDACTED]" : redactCodexProtocolValue(nested), + context === "values" || isSensitiveCodexProtocolKey(key) + ? "[REDACTED]" + : redactCodexProtocolValue( + nested, + key === "mcp_servers" + ? "mcp" + : context === "mcp" && (key === "env" || key === "http_headers") + ? "values" + : context, + ), ]), ); } From 24a08a1ac0fa43c4ecd640a4924b32949caac747 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 17:06:32 +0000 Subject: [PATCH 4/9] fix(providers): fail tool preparation closed and bound MCP diagnostics --- apps/server/src/mcp/resolveAgentTools.ts | 6 +- .../Adapters/ClaudeAdapterV2.ts | 3 +- .../ProviderSessionManager.test.ts | 73 ++++++++++----- .../ProviderSessionManager.ts | 92 ++++++++++--------- packages/contracts/src/agentTools.ts | 11 +++ .../provider-opencode/src/server/adapter.ts | 2 +- .../src/server/v2/adapter.ts | 2 +- 7 files changed, 121 insertions(+), 68 deletions(-) diff --git a/apps/server/src/mcp/resolveAgentTools.ts b/apps/server/src/mcp/resolveAgentTools.ts index bde07687359b2..ac2759a0bf890 100644 --- a/apps/server/src/mcp/resolveAgentTools.ts +++ b/apps/server/src/mcp/resolveAgentTools.ts @@ -1,3 +1,5 @@ +// @effect-diagnostics nodeBuiltinImport:off - The synchronous settings resolver uses Node's synchronous digest. +import * as NodeCrypto from "node:crypto"; import type { ProjectId, ResolvedMcpServer, ServerSettings } from "@t3tools/contracts"; import { resolveProjectSettings } from "@t3tools/shared/projectSettings"; @@ -22,6 +24,8 @@ export function resolveAgentTools( const fingerprint = servers.length === 0 && disabledSkills.length === 0 ? "" - : JSON.stringify({ servers, disabledSkills }); + : NodeCrypto.createHash("sha256") + .update(JSON.stringify({ servers, disabledSkills })) + .digest("hex"); return { servers, disabledSkills, fingerprint }; } diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index c686f55d9f1da..bc1a352459952 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -1306,8 +1306,7 @@ export function claudeMcpQueryOverrides(input: { } /** - * The user's servers for `--mcp-config`. Like T3's own token, a sensitive - * env value or header becomes a `${VAR}` reference there, and its value goes + * The user's servers for `--mcp-config`. A sensitive env value or header becomes a `${VAR}` reference there, and its value goes * into the child's environment. */ function claudeUserMcpServers(servers: ReadonlyArray): { diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts index 1bb4a7e98492f..08447f3784695 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts @@ -15,6 +15,7 @@ import { ProviderDriverKind, ProviderInstanceId, type ProviderSessionId, + ServerSettingsError, ThreadId, } from "@t3tools/contracts"; import * as Cause from "effect/Cause"; @@ -637,6 +638,7 @@ function runBrowserAccessScenario(input: { readonly createThread?: boolean; readonly projectExists?: boolean; readonly toolsOverride?: boolean; + readonly settingsUnavailable?: boolean; }) { return Effect.gen(function* () { const state = yield* Ref.make(emptyState); @@ -678,30 +680,43 @@ function runBrowserAccessScenario(input: { idleTimeoutMs: 1_000, mcpConfigs, projectServiceLayer: layerProjectService, - serverSettingsLayer: ServerSettings.layerTest({ - enableAgentBrowserAccess: input.enableAgentBrowserAccess, - ...(input.toolsOverride - ? { - mcpServers: { - docs: { - enabled: true, - transport: { type: "http", url: "https://example.com/mcp", headers: [] }, - }, - }, - } - : {}), - projectSettingsOverrides: { - [projectId]: { - enableAgentBrowserAccess: input.projectOverride, + serverSettingsLayer: input.settingsUnavailable + ? Layer.mock(ServerSettings.ServerSettingsService)({ + getSettings: Effect.fail( + new ServerSettingsError({ + settingsPath: "/test/settings.json", + operation: "read-file", + cause: new Error("unavailable"), + }), + ), + }) + : ServerSettings.layerTest({ + enableAgentBrowserAccess: input.enableAgentBrowserAccess, ...(input.toolsOverride - ? { mcpServers: { docs: { enabled: false } }, disabledSkills: { review: true } } + ? { + mcpServers: { + docs: { + enabled: true, + transport: { type: "http", url: "https://example.com/mcp", headers: [] }, + }, + }, + } : {}), - ...(input.deviceOverride === undefined - ? {} - : { enableAgentDeviceAccess: input.deviceOverride }), - }, - }, - }), + projectSettingsOverrides: { + [projectId]: { + enableAgentBrowserAccess: input.projectOverride, + ...(input.toolsOverride + ? { + mcpServers: { docs: { enabled: false } }, + disabledSkills: { review: true }, + } + : {}), + ...(input.deviceOverride === undefined + ? {} + : { enableAgentDeviceAccess: input.deviceOverride }), + }, + }, + }), }), ), ); @@ -1941,6 +1956,8 @@ it.effect( }, ]); assert.deepEqual(captured?.tools?.disabledSkills, ["review"]); + assert.match(captured!.tools!.fingerprint, /^[a-f0-9]{64}$/); + assert.notInclude(captured!.tools!.fingerprint, "provider-secret"); const token = captured?.authorizationHeader.replace(/^Bearer\s+/, ""); const resolved = yield* registry.resolve(token!); assert.deepEqual( @@ -2035,6 +2052,18 @@ it.effect("ProviderSessionManagerV2 fails browser access closed for a missing th }), ); +it.effect("ProviderSessionManagerV2 refuses to start with unavailable tool settings", () => + Effect.gen(function* () { + const captured = yield* runBrowserAccessScenario({ + enableAgentBrowserAccess: true, + projectOverride: true, + toolsOverride: true, + settingsUnavailable: true, + }); + assert.isUndefined(captured); + }), +); + it.effect("ProviderSessionManagerV2 revokes MCP credentials when release persistence fails", () => Effect.gen(function* () { const state = yield* Ref.make(emptyState); diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.ts index adecdd3f36649..408e5f2588976 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.ts @@ -10,6 +10,7 @@ import { OrchestrationV2RuntimeRequest, ProviderInstanceId, ProviderSessionId, + ServerSettingsError, ThreadId, type ProviderThreadId, } from "@t3tools/contracts"; @@ -317,12 +318,6 @@ export const layerWithOptions = ( const fileSystem = yield* FileSystem.FileSystem; const mcpSessionRegistry = yield* McpSessionRegistry.McpSessionRegistry; const mcpSessions = yield* McpProviderSessions.McpProviderSessions; - /** - * When present, an unreadable settings file withholds browser access - * rather than granting it — an explicit "off" silently becoming "on" - * would violate the user's stated choice, whereas the reverse costs an - * agent one toolset and is visible immediately (#7083). - */ const serverSettings = yield* Effect.serviceOption(ServerSettings.ServerSettingsService); const projectService = yield* Effect.serviceOption(ProjectService.ProjectService); const eventSink = yield* EventSink.EventSinkV2; @@ -339,8 +334,8 @@ export const layerWithOptions = ( device: false, tools: EMPTY_MCP_PROVIDER_SESSION_TOOLS, }; + const settings = yield* serverSettings.value.getSettings; return yield* Effect.gen(function* () { - const settings = yield* serverSettings.value.getSettings; const thread = yield* projectionStore.getThread(threadId); const entries = Object.values(settings.projectSettingsOverrides); const browserOverridden = entries.some( @@ -450,7 +445,7 @@ export const layerWithOptions = ( const prepareMcpSession = ( threadId: ThreadId, providerInstanceId: ProviderInstanceId, - ): Effect.Effect => + ): Effect.Effect => options.configureMcp === false ? mcpSessions .clear(threadId) @@ -1383,7 +1378,19 @@ export const layerWithOptions = ( Effect.uninterruptible, ); if (attached !== undefined) { - const prepared = yield* prepareMcpSession(input.threadId, input.providerInstanceId); + const prepared = yield* prepareMcpSession( + input.threadId, + input.providerInstanceId, + ).pipe( + Effect.mapError( + (cause) => + new ProviderSessionOpenError({ + instanceId: input.providerInstanceId, + providerSessionId: input.providerSessionId, + cause, + }), + ), + ); preparedForCleanup = prepared; if (prepared.mcpCredentialId !== undefined) { const mcpCredentialId = prepared.mcpCredentialId; @@ -1728,6 +1735,28 @@ export const layerWithOptions = ( >, ): ProviderAdapter.ProviderAdapterV2SessionRuntime => { const providerSessionId = runtime.providerSessionId; + const ensureRuntimeThreadAttached = (threadId: ThreadId) => + ensureThreadAttached({ + providerSessionId, + threadId, + providerInstanceId: runtime.instanceId, + }).pipe( + Effect.catchTags({ + ProviderSessionOpenError: (cause) => + Effect.fail( + new ProviderAdapter.ProviderAdapterEnsureThreadError({ + driver: runtime.driver, + threadId, + cause, + }), + ), + ProviderSessionActivityError: (cause) => + Effect.logWarning("orchestration-v2.driver-session.activity-failed", { + providerSessionId, + cause, + }), + }), + ); const subscribeEvents = makeEventSubscription(eventSubscribers); const turnMetrics = (operation: string, model?: string) => withMetrics({ @@ -1746,14 +1775,7 @@ export const layerWithOptions = ( subscribeEvents.pipe(Effect.map((subscription) => subscription.events)), ), ensureThread: (input) => - observeActivity( - providerSessionId, - ensureThreadAttached({ - providerSessionId, - threadId: input.threadId, - providerInstanceId: runtime.instanceId, - }), - ).pipe( + ensureRuntimeThreadAttached(input.threadId).pipe( Effect.andThen(runtime.ensureThread(input)), Effect.tap((providerThread) => markProviderThreadLoaded({ @@ -1779,14 +1801,7 @@ export const layerWithOptions = ( : { modelSelection: input.modelSelection }), ...(input.runtimePolicy === undefined ? {} : { runtimePolicy: input.runtimePolicy }), }); - return observeActivity( - providerSessionId, - ensureThreadAttached({ - providerSessionId, - threadId, - providerInstanceId: runtime.instanceId, - }), - ).pipe( + return ensureRuntimeThreadAttached(threadId).pipe( Effect.andThen( holdThreadLoaded({ providerSessionId, @@ -1818,14 +1833,7 @@ export const layerWithOptions = ( ); }, forkThread: (input) => - observeActivity( - providerSessionId, - ensureThreadAttached({ - providerSessionId, - threadId: input.targetThreadId, - providerInstanceId: runtime.instanceId, - }), - ).pipe( + ensureRuntimeThreadAttached(input.targetThreadId).pipe( Effect.andThen(runtime.forkThread(input)), Effect.tap((providerThread) => markProviderThreadLoaded({ @@ -1844,14 +1852,7 @@ export const layerWithOptions = ( ), ), startTurn: (input) => - observeActivity( - providerSessionId, - ensureThreadAttached({ - providerSessionId, - threadId: input.threadId, - providerInstanceId: runtime.instanceId, - }), - ).pipe( + ensureRuntimeThreadAttached(input.threadId).pipe( // A start that fails or is stopped may never emit turn.terminal, // so it clears its own turn or the session never goes idle. Effect.andThen( @@ -2136,6 +2137,15 @@ export const layerWithOptions = ( const prepared = yield* prepareMcpSession( input.threadId, input.modelSelection.instanceId, + ).pipe( + Effect.mapError( + (cause) => + new ProviderSessionOpenError({ + instanceId: input.modelSelection.instanceId, + providerSessionId: input.providerSessionId, + cause, + }), + ), ); const mcpCredentialId = prepared.mcpCredentialId; let reservationDropped = mcpCredentialId === undefined; diff --git a/packages/contracts/src/agentTools.ts b/packages/contracts/src/agentTools.ts index 6576ec99350ef..1acb3cc242259 100644 --- a/packages/contracts/src/agentTools.ts +++ b/packages/contracts/src/agentTools.ts @@ -85,3 +85,14 @@ export interface ResolvedMcpServer { readonly name: McpServerName; readonly transport: McpServerTransport; } + +export function mcpServerVariableRecord( + variables: ReadonlyArray, +): Record { + const record: Record = {}; + for (const variable of variables) { + if (variable.valueRedacted === true && variable.value.length === 0) continue; + record[variable.name] = variable.value; + } + return record; +} diff --git a/packages/provider-opencode/src/server/adapter.ts b/packages/provider-opencode/src/server/adapter.ts index 2f50b29b3dc8f..311cfebaffce3 100644 --- a/packages/provider-opencode/src/server/adapter.ts +++ b/packages/provider-opencode/src/server/adapter.ts @@ -1017,7 +1017,7 @@ export const makeOpenCodeAdapterV2 = Effect.fn("makeOpenCodeAdapterV2")(function Effect.catchCause((cause) => Effect.logWarning("Could not add an MCP server to OpenCode.", { server: server.name, - cause, + errorTag: causeErrorTag(cause), }), ), ); diff --git a/packages/provider-opencode/src/server/v2/adapter.ts b/packages/provider-opencode/src/server/v2/adapter.ts index b14189db20e95..306c47decb7a8 100644 --- a/packages/provider-opencode/src/server/v2/adapter.ts +++ b/packages/provider-opencode/src/server/v2/adapter.ts @@ -3071,7 +3071,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr Effect.catchCause((cause) => Effect.logWarning("Could not add an MCP server to OpenCode.", { server: server.name, - cause, + errorTag: causeErrorTag(cause), }).pipe(Effect.as(false)), ), ); From e9d91669639f2c6c998f897681928419492858c1 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 17:58:30 +0000 Subject: [PATCH 5/9] fix(opencode): recover failed MCP connections and revocations --- .../Adapters/OpenCode2AdapterV2.test.ts | 270 ++++++++++++++---- .../Adapters/OpenCode2AdapterV2.testkit.ts | 62 +++- .../src/server/v2/adapter.ts | 202 ++++++++----- 3 files changed, 411 insertions(+), 123 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts index 6e1260e38cef1..b00414d95c59d 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.test.ts @@ -3273,67 +3273,46 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { ...supervisedRules, { action: `${prefix}-*`, resource: "*", effect: "ask" }, ]; - const t3Server = "t3-code-thread_opencode2-adapter"; - const addT3 = out("mcp.add", { - server: t3Server, - "location[directory]": WORK, - config: { - type: "remote", - url: "http://127.0.0.1:3773/mcp", - headers: { Authorization: "Bearer thread-credential" }, - oauth: false, - }, - }); - const addUser = (name: string) => - out("mcp.add", { - server: `${prefix}-${name}`, - "location[directory]": WORK, - config: { type: "remote", url: `https://${name}.example/mcp`, headers: {} }, - }); + const mcp = { + servers: new Map(), + failingConnections: new Set([`${prefix}-retry`]), + failingRemovals: new Set(), + calls: [] as Array<{ type: string; server: string }>, + }; const turn = [ out("session.prompt", { sessionID: SESSION, text: "" }), promptAccepted, event("session.execution.succeeded", { sessionID: SESSION }), ]; - const runtime = yield* openCode2ReplayRuntime([ - ...opening, - out("session.get", { sessionID: SESSION }), - replyData("session.get", sessionInfo()), - ...noOpenRequests, - out("agent.list", ""), - reply("agent.list", agentList), - out("session.update", { sessionID: SESSION, permissions: ownRules }), - reply("session.update", null), - addT3, - reply("mcp.add", null), - addUser("healthy"), - reply("mcp.add", null), - addUser("retry"), - reply("mcp.add", { status: 500, body: { message: "Unavailable" } }), - out("session.instructions.entry.put", { - sessionID: SESSION, - key: "t3-code", - value: "", - }), - reply("session.instructions.entry.put", null), - ...turn, - addT3, - reply("mcp.add", null), - out("mcp.list", { "location[directory]": WORK }), - reply("mcp.list", { - location: { directory: WORK }, - data: [{ name: `${prefix}-healthy`, status: { status: "connected" } }], - }), - addUser("retry"), - reply("mcp.add", null), - ...turn, - out("mcp.remove", { server: t3Server, "location[directory]": WORK }), - reply("mcp.remove", null), - out("mcp.remove", { server: `${prefix}-healthy`, "location[directory]": WORK }), - out("mcp.remove", { server: `${prefix}-retry`, "location[directory]": WORK }), - reply("mcp.remove", null), - reply("mcp.remove", null), - ]); + const runtime = yield* openCode2ReplayRuntime( + [ + ...opening, + out("session.get", { sessionID: SESSION }), + replyData("session.get", sessionInfo()), + ...noOpenRequests, + out("agent.list", ""), + reply("agent.list", agentList), + out("session.update", { sessionID: SESSION, permissions: ownRules }), + reply("session.update", null), + out("session.instructions.entry.put", { + sessionID: SESSION, + key: "t3-code", + value: "", + }), + reply("session.instructions.entry.put", null), + ...turn, + ...turn, + out("session.update", { + sessionID: SESSION, + permissions: [ + ...supervisedRules, + { action: `${prefix}-*`, resource: "*", effect: "deny" }, + ], + }), + reply("session.update", null), + ], + { mcp }, + ); const thread = yield* runtime.resumeThread({ providerThread: providerThread(yield* DateTime.now), threadId, @@ -3344,8 +3323,187 @@ it.layer(McpProviderSessions.layer)("OpenCode2 adapter", (it) => { const terminal = yield* terminalOf(runtime).pipe(Effect.forkScoped); yield* runtime.startTurn(turnInput(thread, bigPickle, "approval-required")); assert.equal((yield* Fiber.join(terminal))?.status, "completed"); + assert.equal( + mcp.servers.get(`${prefix}-retry`)?.status, + index === 0 ? "failed" : "connected", + ); + mcp.failingConnections.clear(); } + assert.deepEqual( + mcp.calls.filter((call) => call.server.startsWith(prefix)), + [ + { type: "mcp.add", server: `${prefix}-healthy` }, + { type: "mcp.add", server: `${prefix}-retry` }, + { type: "mcp.connect", server: `${prefix}-retry` }, + ], + ); yield* runtime.unloadThread!({ providerThread: thread }); + assert.equal(mcp.servers.size, 0); + }).pipe(Effect.scoped), + ); + + it.effect( + "blocks revoked user MCP use and retries failed removal on settings, directory and unload changes", + () => + Effect.gen(function* () { + const mcpSessions = yield* McpProviderSessions.McpProviderSessions; + const prefix = "t3u-c26f2f1f"; + const ownRules = [ + ...supervisedRules, + { action: `${prefix}-*`, resource: "*", effect: "ask" }, + ]; + const deniedRules = [ + ...supervisedRules, + { action: `${prefix}-*`, resource: "*", effect: "deny" }, + ]; + const update = (permissions: ReadonlyArray) => [ + out("session.update", { sessionID: SESSION, permissions }), + reply("session.update", null), + ]; + const turn = [ + out("session.prompt", { sessionID: SESSION, text: "" }), + promptAccepted, + event("session.execution.succeeded", { sessionID: SESSION }), + ]; + for (const change of [ + "disable", + "replace", + "directory", + "unload", + "resume", + "cleanup", + ] as const) { + const mcp = yield* Effect.gen(function* () { + const config = { + environmentId: EnvironmentId.make("environment:opencode2-adapter"), + threadId, + providerSessionId: "mcp:opencode2-adapter", + providerInstanceId: instanceId, + endpoint: "http://127.0.0.1:3773/mcp", + authorizationHeader: "Bearer thread-credential", + browserToolsAvailable: false, + tools: { + servers: [ + { + name: "docs", + transport: { + type: "http" as const, + url: "https://old.example/mcp", + headers: [], + }, + }, + ], + disabledSkills: [], + fingerprint: "old", + }, + }; + yield* mcpSessions.set(config); + yield* Effect.addFinalizer(() => mcpSessions.clear(threadId)); + const mcp = { + servers: new Map(), + failingConnections: new Set(), + failingRemovals: new Set(), + calls: [] as Array<{ type: string; server: string }>, + }; + const nextRules = change === "disable" ? supervisedRules : ownRules; + const runtime = yield* openCode2ReplayRuntime( + [ + ...opening, + out("session.get", { sessionID: SESSION }), + replyData("session.get", sessionInfo()), + ...noOpenRequests, + out("agent.list", ""), + reply("agent.list", agentList), + ...update(ownRules), + out("session.instructions.entry.put", { + sessionID: SESSION, + key: "t3-code", + value: "", + }), + reply("session.instructions.entry.put", null), + ...turn, + ...(change === "disable" ? update(nextRules) : []), + ...update(deniedRules), + ...(change === "unload" || change === "cleanup" + ? [] + : [ + ...update(nextRules), + ...turn, + ...(change === "disable" ? [] : update(deniedRules)), + ]), + ], + { mcp }, + ); + const thread = yield* runtime.resumeThread({ + providerThread: providerThread(yield* DateTime.now), + threadId, + modelSelection: bigPickle, + runtimePolicy: policy("approval-required"), + }); + const completed = yield* terminalOf(runtime).pipe(Effect.forkScoped); + yield* runtime.startTurn(turnInput(thread, bigPickle, "approval-required")); + assert.equal((yield* Fiber.join(completed))?.status, "completed"); + mcp.failingRemovals.add(`${prefix}-docs`); + if (change === "disable" || change === "replace") { + yield* mcpSessions.set({ + ...config, + tools: { + ...config.tools, + fingerprint: "new", + servers: + change === "disable" + ? [] + : [ + { + name: "docs", + transport: { + type: "http", + url: "https://new.example/mcp", + headers: [], + }, + }, + ], + }, + }); + } + const input = turnInput(thread, bigPickle, "approval-required"); + const changedInput = + change === "directory" + ? { ...input, runtimePolicy: { ...input.runtimePolicy, cwd: "/work/other" } } + : input; + const failed = yield* Effect.exit( + change === "unload" || change === "resume" || change === "cleanup" + ? runtime.unloadThread!({ providerThread: thread }) + : runtime.startTurn(changedInput), + ); + assert.equal(failed._tag, "Failure", change); + assert.equal(mcp.servers.get(`${prefix}-docs`)?.status, "connected"); + assert.equal( + mcp.calls.filter( + (call) => call.type === "mcp.remove" && call.server === `${prefix}-docs`, + ).length, + 1, + ); + mcp.failingRemovals.clear(); + if (change === "cleanup") return mcp; + if (change !== "unload") { + const retried = yield* terminalOf(runtime).pipe(Effect.forkScoped); + yield* runtime.startTurn(changedInput); + assert.equal((yield* Fiber.join(retried))?.status, "completed"); + assert.equal(mcp.servers.has(`${prefix}-docs`), change !== "disable"); + } + yield* runtime.unloadThread!({ providerThread: thread }); + assert.equal(mcp.servers.size, 0); + assert.equal( + mcp.calls.filter( + (call) => call.type === "mcp.remove" && call.server === `${prefix}-docs`, + ).length, + change === "disable" || change === "unload" ? 2 : 3, + ); + return mcp; + }).pipe(Effect.scoped); + assert.equal(mcp.servers.size, 0); + } }).pipe(Effect.scoped), ); diff --git a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts index 7b1610a31e0e0..7b4a851ae3a92 100644 --- a/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts +++ b/apps/server/src/orchestration-v2/Adapters/OpenCode2AdapterV2.testkit.ts @@ -65,6 +65,10 @@ const operationOf = ( if (mcp !== null && method === "DELETE") { return { type: "mcp.remove", input: { server: mcp[1], ...query } }; } + const connectMcp = /^\/api\/experimental\/mcp\/([^/]+)\/connect$/.exec(path); + if (connectMcp !== null && method === "POST") { + return { type: "mcp.connect", input: { server: connectMcp[1], ...query } }; + } const entry = /^\/api\/experimental\/session\/([^/]+)\/instructions\/entries\/([^/]+)$/.exec( path, ); @@ -125,9 +129,59 @@ const operationOf = ( return { type: `${method} ${path}`, input: { ...query, body } }; }; +interface McpReplayState { + readonly servers: Map; + readonly failingConnections: Set; + readonly failingRemovals: Set; + readonly calls: Array<{ readonly type: string; readonly server: string }>; +} + +const mcpResponse = ( + state: McpReplayState, + operation: { readonly type: string; readonly input?: unknown }, +) => { + const input = operation.input as Record; + if (operation.type === "mcp.list") { + return new Response( + encodeJson({ + location: { directory: input["location[directory]"] }, + data: [...state.servers].map(([name, entry]) => ({ + name, + status: { + status: entry.status, + ...(entry.status === "failed" ? { error: "Unavailable" } : {}), + }, + })), + }), + { headers: { "content-type": "application/json" } }, + ); + } + const server = String(input.server); + state.calls.push({ type: operation.type, server }); + if (operation.type === "mcp.add") { + const previous = state.servers.get(server); + // OpenCode 2.0.28 reconciles only changed configs. Repeating add cannot heal. + if (JSON.stringify(previous?.config) !== JSON.stringify(input.config)) { + state.servers.set(server, { + config: input.config, + status: state.failingConnections.has(server) ? "failed" : "connected", + }); + } + } else if (operation.type === "mcp.connect") { + const entry = state.servers.get(server); + if (entry !== undefined) + entry.status = state.failingConnections.has(server) ? "failed" : "connected"; + } else if (operation.type === "mcp.remove") { + if (state.failingRemovals.has(server)) return new Response(null, { status: 500 }); + state.servers.delete(server); + } + return new Response(null, { status: 204 }); +}; + const replayHttpClient = ( controller: OpenCodeReplayController, replayGate: ProviderReplayGate | undefined, + mcp: McpReplayState | undefined, ) => HttpClient.make((request, url) => Effect.tryPromise({ @@ -149,6 +203,9 @@ const replayHttpClient = ( // The event stream and requests are separate connections: a request // is matched only once what was recorded before it was delivered. if (operation.type !== "event.subscribe") await controller.untilInboundDelivered(); + if (mcp !== undefined && operation.type.startsWith("mcp.")) { + return mcpResponse(mcp, operation); + } await controller.expectOutbound(operation); if (operation.type === "event.subscribe") { controller.exited = false; @@ -188,6 +245,7 @@ export const replayServer = ( transcript: ProviderReplayTranscript, options?: { readonly external?: boolean; + readonly mcp?: McpReplayState; readonly replayGate?: ProviderReplayGate; readonly borrowers?: { current: number }; }, @@ -203,7 +261,7 @@ export const replayServer = ( const opencode = yield* OpenCode2Client.make.pipe( Effect.provideService( HttpClient.HttpClient, - replayHttpClient(controller, options?.replayGate), + replayHttpClient(controller, options?.replayGate, options?.mcp), ), ); const connection = { @@ -234,6 +292,7 @@ const makeReplayAdapter = ( transcript: ProviderReplayTranscript, options?: { readonly external?: boolean; + readonly mcp?: McpReplayState; readonly replayGate?: ProviderReplayGate; readonly borrowers?: { current: number }; }, @@ -262,6 +321,7 @@ export const openCode2ReplayRuntime = ( entries: ReadonlyArray, options?: { readonly external?: boolean; + readonly mcp?: McpReplayState; readonly borrowers?: { current: number }; readonly replayGate?: ProviderReplayGate; }, diff --git a/packages/provider-opencode/src/server/v2/adapter.ts b/packages/provider-opencode/src/server/v2/adapter.ts index 306c47decb7a8..06b18d74434c8 100644 --- a/packages/provider-opencode/src/server/v2/adapter.ts +++ b/packages/provider-opencode/src/server/v2/adapter.ts @@ -312,6 +312,7 @@ interface ThreadState { } interface UserMcpRegistration { + readonly revoked?: boolean; readonly names: ReadonlyArray; readonly directory: string; readonly fingerprint: string; @@ -2755,7 +2756,16 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr }); const writeRules = Effect.fnUntraced(function* (state: ThreadState, policy: RulesPolicy) { - const rules = yield* rulesFor(state, policy, rootOf(state).providerThread.appThreadId); + const root = rootOf(state); + const appThreadId = root.providerThread.appThreadId; + let rules = yield* rulesFor(state, policy, appThreadId); + if (root.userMcp?.revoked && appThreadId !== null) { + const prefix = yield* userMcpPrefixFor(appThreadId); + rules = [ + ...rules.filter((entry) => entry.action !== `${prefix}-*`), + rule(`${prefix}-*`, "deny"), + ]; + } if (!sameRules(state.rules, rules)) { yield* client.session.update({ sessionID: Session.ID.make(state.sessionId), @@ -2978,29 +2988,83 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr const removeMcp = (mcp: { readonly name: string; readonly directory: string }) => Effect.suspend(() => client.mcp.remove({ server: mcp.name, location: { directory: mcp.directory } }), - ).pipe(Effect.timeout("5 seconds"), Effect.ignore({ log: true })); + ).pipe( + Effect.timeout("5 seconds"), + Effect.catchTags({ McpServerNotFoundError: () => Effect.void }), + ); - const removeUserMcp = (registration: UserMcpRegistration) => - Effect.forEach( + const removeUserMcp = Effect.fnUntraced(function* (state: ThreadState) { + const registration = state.userMcp; + if (registration === undefined) return; + state.userMcp = { ...registration, revoked: true }; + // Revoke the namespace before deleting credentials; a failed removal must + // not leave the old servers usable by this session, including its grants. + const appThreadId = state.providerThread.appThreadId; + if (appThreadId !== null) { + const prefix = yield* userMcpPrefixFor(appThreadId); + yield* Effect.forEach( + sessionsOf(state), + (session) => + Effect.gen(function* () { + const rules = [ + ...(session.rules ?? []).filter((entry) => entry.action !== `${prefix}-*`), + rule(`${prefix}-*`, "deny"), + ]; + if (!sameRules(session.rules, rules)) { + yield* client.session + .update({ + sessionID: Session.ID.make(session.sessionId), + permissions: rules, + }) + .pipe( + Effect.timeout("5 seconds"), + Effect.catchTags({ SessionNotFoundError: () => Effect.void }), + ); + session.rules = rules; + } + }), + { concurrency: 8, discard: true }, + ); + } + const remaining = yield* Effect.forEach( registration.names, - (name) => removeMcp({ name, directory: registration.directory }), - { concurrency: 8, discard: true }, + (name) => + removeMcp({ name, directory: registration.directory }).pipe( + Effect.as([] as string[]), + Effect.catchCause((cause) => + Effect.logWarning("Could not remove an MCP server from OpenCode.", { + errorTag: causeErrorTag(cause), + }).pipe(Effect.as([name])), + ), + ), + { concurrency: 8 }, ); + const names = remaining.flat(); + state.userMcp = names.length === 0 ? undefined : { ...registration, names, revoked: true }; + if (names.length > 0) { + return yield* new ProviderAdapter.ProviderAdapterProtocolError({ + driver, + detail: "Could not revoke previous MCP servers in OpenCode. Retry before continuing.", + }); + } + }); - // T3's MCP registrations outlive a session only on an external server; a - // spawned one forgets them when it stops. + // Failed unloads stay in threads so closing the runtime retries cleanup. yield* Effect.addFinalizer(() => Effect.forEach( - [...threads.values()].flatMap((state) => [ - ...(state.mcp === undefined ? [] : [state.mcp]), - ...(state.userMcp === undefined - ? [] - : state.userMcp.names.map((name) => ({ - name, - directory: state.userMcp!.directory, - }))), - ]), - removeMcp, + threads.values(), + (state) => + Effect.gen(function* () { + if (state.mcp !== undefined) + yield* removeMcp(state.mcp).pipe(Effect.ignore({ log: true })); + yield* removeUserMcp(state).pipe( + Effect.catchCause((cause) => + Effect.logWarning("Could not clean up OpenCode MCP registrations.", { + errorTag: causeErrorTag(cause), + }), + ), + ); + }), { concurrency: 8, discard: true }, ), ); @@ -3022,11 +3086,11 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr const current = state.userMcp; const unchanged = current !== undefined && + !current.revoked && current.directory === directory && current.fingerprint === tools.fingerprint; if (current !== undefined && !unchanged) { - yield* removeUserMcp(current); - state.userMcp = undefined; + yield* removeUserMcp(state); } if (tools.servers.length === 0) return; const prefix = yield* userMcpPrefixFor(threadId); @@ -3034,54 +3098,49 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr ? yield* client.mcp.list({ location: { directory } }).pipe( Effect.timeout(INVENTORY_TIMEOUT), Effect.map( - (listed) => - new Set( - listed.data - .filter((entry) => entry.status.status !== "failed") - .map((entry) => entry.name), - ), + (listed) => new Map(listed.data.map((entry) => [entry.name, entry.status.status])), ), - Effect.orElseSucceed(() => new Set(current.names)), + Effect.orElseSucceed(() => new Map(current.names.map((name) => [name, "connected"]))), ) - : new Set(); - const names = unchanged ? current.names.filter((name) => inventory.has(name)) : []; + : new Map(); + const names = unchanged ? [...current.names] : []; + state.userMcp = { names, directory, fingerprint: tools.fingerprint }; for (const server of tools.servers) { const name = `${prefix}-${server.name}`; - if (names.includes(name)) continue; - const added = yield* client.mcp - .add({ - server: name, - location: { directory }, - config: - server.transport.type === "stdio" - ? new Mcp.LocalConfig({ - type: "local", - command: [server.transport.command, ...server.transport.args], - environment: mcpServerVariableRecord(server.transport.env), - }) - : new Mcp.RemoteConfig({ - type: "remote", - url: server.transport.url, - headers: mcpServerVariableRecord(server.transport.headers), - }), - }) - .pipe( - Effect.timeout(INVENTORY_TIMEOUT), - Effect.as(true), - Effect.catchCause((cause) => - Effect.logWarning("Could not add an MCP server to OpenCode.", { - server: server.name, - errorTag: causeErrorTag(cause), - }).pipe(Effect.as(false)), - ), - ); - if (added) names.push(name); + const status = inventory.get(name); + if (status !== undefined && status !== "failed") continue; + // Even an unsuccessful request may have installed credential-bearing + // config. Keep it tracked until deletion succeeds. + if (!names.includes(name)) names.push(name); + yield* ( + status === "failed" + ? client.mcp.connect({ server: name, location: { directory } }) + : client.mcp.add({ + server: name, + location: { directory }, + config: + server.transport.type === "stdio" + ? new Mcp.LocalConfig({ + type: "local", + command: [server.transport.command, ...server.transport.args], + environment: mcpServerVariableRecord(server.transport.env), + }) + : new Mcp.RemoteConfig({ + type: "remote", + url: server.transport.url, + headers: mcpServerVariableRecord(server.transport.headers), + }), + }) + ).pipe( + Effect.timeout(INVENTORY_TIMEOUT), + Effect.catchCause((cause) => + Effect.logWarning("Could not connect an MCP server to OpenCode.", { + server: server.name, + errorTag: causeErrorTag(cause), + }), + ), + ); } - state.userMcp = { - names, - directory, - fingerprint: tools.fingerprint, - }; }); /** @@ -3111,7 +3170,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr state.mcp.directory !== wanted.directory || state.mcp.credential !== wanted.credential) ) { - yield* removeMcp(state.mcp); + yield* removeMcp(state.mcp).pipe(Effect.ignore({ log: true })); state.mcp = undefined; } // Idle Location eviction drops runtime MCP servers without clearing T3's cache. @@ -3141,6 +3200,7 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr if (mcpAvailable) state.mcp = wanted; } yield* prepareUserMcp(state, turnInput.threadId, directory, mcpSession); + yield* writeRules(state, turnInput.runtimePolicy); const instructions = [ buildRuntimeInstructions({ harness: "OpenCode", model: turnInput.modelSelection.model }), t3OrchestrationSystemPrompt(mcpAvailable), @@ -3850,14 +3910,24 @@ export const make = Effect.fn("OpenCode2Adapter.make")(function* (instanceId: Pr ) { return; } + yield* removeUserMcp(state).pipe( + Effect.mapError((cause) => + isProviderAdapterError(cause) + ? cause + : new ProviderAdapter.ProviderAdapterProtocolError({ + driver, + detail: "Could not revoke MCP servers before unloading OpenCode.", + }), + ), + ); threads.delete(nativeId); for (const [child, owner] of childOwners) { if (owner !== state) continue; childOwners.delete(child); threads.delete(child); } - if (state.mcp !== undefined) yield* removeMcp(state.mcp); - if (state.userMcp !== undefined) yield* removeUserMcp(state.userMcp); + if (state.mcp !== undefined) + yield* removeMcp(state.mcp).pipe(Effect.ignore({ log: true })); }), respondToRuntimeRequest: (requestInput) => Effect.gen(function* () { From c9dfc060a30ce93de4ccb8e107e1d139f0e8b9e4 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 18:52:29 +0000 Subject: [PATCH 6/9] fix(providers): retain disabled skills when project lookup fails --- .../src/orchestration-v2/ProviderSessionManager.test.ts | 6 ++++++ apps/server/src/orchestration-v2/ProviderSessionManager.ts | 2 +- 2 files changed, 7 insertions(+), 1 deletion(-) diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts index 08447f3784695..14c5d1557034c 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts @@ -638,6 +638,7 @@ function runBrowserAccessScenario(input: { readonly createThread?: boolean; readonly projectExists?: boolean; readonly toolsOverride?: boolean; + readonly disabledSkills?: ReadonlyArray; readonly settingsUnavailable?: boolean; }) { return Effect.gen(function* () { @@ -692,6 +693,7 @@ function runBrowserAccessScenario(input: { }) : ServerSettings.layerTest({ enableAgentBrowserAccess: input.enableAgentBrowserAccess, + disabledSkills: input.disabledSkills ?? [], ...(input.toolsOverride ? { mcpServers: { @@ -2046,9 +2048,13 @@ it.effect("ProviderSessionManagerV2 fails browser access closed for a missing th enableAgentBrowserAccess: true, projectOverride: true, createThread: false, + toolsOverride: true, + disabledSkills: ["environment-off"], }); assert.isDefined(captured); assert.equal(captured?.browserToolsAvailable, false); + assert.deepEqual(captured?.tools?.disabledSkills, ["environment-off"]); + assert.deepEqual(captured?.tools?.servers, []); }), ); diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.ts index 408e5f2588976..478b61d36ac5f 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.ts @@ -370,7 +370,7 @@ export const layerWithOptions = ( Effect.as({ browser: false, device: false, - tools: EMPTY_MCP_PROVIDER_SESSION_TOOLS, + tools: { ...resolveAgentTools(settings, null), servers: [] }, }), ), ), From f950289ffdfc7ab24eea889b9c7efef4e7818090 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 19:11:06 +0000 Subject: [PATCH 7/9] fix(providers): fingerprint withheld MCP server configuration --- .../ProviderSessionManager.test.ts | 23 ++++++++++++++++--- .../ProviderSessionManager.ts | 2 +- 2 files changed, 21 insertions(+), 4 deletions(-) diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts index 14c5d1557034c..bf88c340fec60 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts @@ -638,6 +638,7 @@ function runBrowserAccessScenario(input: { readonly createThread?: boolean; readonly projectExists?: boolean; readonly toolsOverride?: boolean; + readonly projectToolsOverride?: boolean; readonly disabledSkills?: ReadonlyArray; readonly settingsUnavailable?: boolean; }) { @@ -707,7 +708,7 @@ function runBrowserAccessScenario(input: { projectSettingsOverrides: { [projectId]: { enableAgentBrowserAccess: input.projectOverride, - ...(input.toolsOverride + ...(input.toolsOverride && input.projectToolsOverride !== false ? { mcpServers: { docs: { enabled: false } }, disabledSkills: { review: true }, @@ -2044,17 +2045,33 @@ it.effect("ProviderSessionManagerV2 fails browser access closed for a missing pr it.effect("ProviderSessionManagerV2 fails browser access closed for a missing thread", () => Effect.gen(function* () { - const captured = yield* runBrowserAccessScenario({ + const environment = { enableAgentBrowserAccess: true, projectOverride: true, + disabledSkills: ["environment-off"], + }; + const healthy = yield* runBrowserAccessScenario({ + ...environment, + toolsOverride: true, + projectToolsOverride: false, + }); + assert.deepEqual( + healthy?.tools?.servers.map((server) => server.name), + ["docs"], + ); + assert.deepEqual(healthy?.tools?.disabledSkills, ["environment-off"]); + const captured = yield* runBrowserAccessScenario({ + ...environment, createThread: false, toolsOverride: true, - disabledSkills: ["environment-off"], }); assert.isDefined(captured); assert.equal(captured?.browserToolsAvailable, false); assert.deepEqual(captured?.tools?.disabledSkills, ["environment-off"]); assert.deepEqual(captured?.tools?.servers, []); + assert.notEqual(captured?.tools?.fingerprint, healthy?.tools?.fingerprint); + const withoutServers = yield* runBrowserAccessScenario(environment); + assert.deepEqual(captured?.tools, withoutServers?.tools); }), ); diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.ts index 478b61d36ac5f..a3a92981ea942 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.ts @@ -370,7 +370,7 @@ export const layerWithOptions = ( Effect.as({ browser: false, device: false, - tools: { ...resolveAgentTools(settings, null), servers: [] }, + tools: resolveAgentTools({ ...settings, mcpServers: {} }, null), }), ), ), From e63737002351c7abffb2353a3664e232ee3699d4 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 19:47:00 +0000 Subject: [PATCH 8/9] fix(providers): preserve project skill restrictions on lookup failure --- .../ProviderSessionManager.test.ts | 80 +++++++++++++------ .../ProviderSessionManager.ts | 31 +++++-- 2 files changed, 80 insertions(+), 31 deletions(-) diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts index bf88c340fec60..ec537e753dd89 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.test.ts @@ -637,6 +637,7 @@ function runBrowserAccessScenario(input: { readonly deviceOverride?: boolean; readonly createThread?: boolean; readonly projectExists?: boolean; + readonly projectLookupFails?: boolean; readonly toolsOverride?: boolean; readonly projectToolsOverride?: boolean; readonly disabledSkills?: ReadonlyArray; @@ -651,14 +652,22 @@ function runBrowserAccessScenario(input: { const threadId = ThreadId.make("thread-provider-session-manager-browser-access"); const layerProjectService = Layer.mock(ProjectService.ProjectService)({ getById: (requestedProjectId) => - Effect.succeed( - input.projectExists === false - ? Option.none() - : Option.some(makeBrowserAccessProject(requestedProjectId)), - ), + input.projectLookupFails + ? Effect.fail( + new ProjectService.ProjectOperationError({ + operation: "read-project", + projectId: requestedProjectId, + cause: new Error("project store unavailable"), + }), + ) + : Effect.succeed( + input.projectExists === false + ? Option.none() + : Option.some(makeBrowserAccessProject(requestedProjectId)), + ), }); - yield* Effect.gen(function* () { + const opened = yield* Effect.gen(function* () { const eventSink = yield* EventSink.EventSinkV2; const idAllocator = yield* IdAllocator.IdAllocatorV2; const manager = yield* ProviderSessionManager.ProviderSessionManagerV2; @@ -672,9 +681,9 @@ function runBrowserAccessScenario(input: { events: [yield* makeThreadCreatedEvent({ idAllocator, threadId, now, projectId })], }); } - yield* manager + return yield* manager .open({ threadId, providerSessionId, modelSelection, runtimePolicy }) - .pipe(Effect.ignore); + .pipe(Effect.result); }).pipe( Effect.provide( layerTest({ @@ -724,7 +733,7 @@ function runBrowserAccessScenario(input: { ), ); - return (yield* Ref.get(mcpConfigs))[0]; + return { config: (yield* Ref.get(mcpConfigs))[0], opened }; }); } @@ -2008,7 +2017,7 @@ it.effect( it.effect("ProviderSessionManagerV2 honors a project browser-access opt-out", () => Effect.gen(function* () { - const captured = yield* runBrowserAccessScenario({ + const { config: captured } = yield* runBrowserAccessScenario({ enableAgentBrowserAccess: true, projectOverride: false, }); @@ -2019,7 +2028,7 @@ it.effect("ProviderSessionManagerV2 honors a project browser-access opt-out", () it.effect("ProviderSessionManagerV2 honors a project browser-access opt-in", () => Effect.gen(function* () { - const captured = yield* runBrowserAccessScenario({ + const { config: captured } = yield* runBrowserAccessScenario({ enableAgentBrowserAccess: false, projectOverride: true, }); @@ -2030,16 +2039,29 @@ it.effect("ProviderSessionManagerV2 honors a project browser-access opt-in", () it.effect("ProviderSessionManagerV2 fails browser access closed for a missing project", () => Effect.gen(function* () { - const captured = yield* runBrowserAccessScenario({ + const settings = { enableAgentBrowserAccess: true, projectOverride: true, - projectExists: false, + deviceOverride: true, toolsOverride: true, + disabledSkills: ["environment-off"], + }; + const { config: missing } = yield* runBrowserAccessScenario({ + ...settings, + projectExists: false, }); - assert.isDefined(captured); - assert.equal(captured?.browserToolsAvailable, false); - assert.deepEqual(captured?.tools?.servers, []); - assert.deepEqual(captured?.tools?.disabledSkills, ["review"]); + const { config: failed } = yield* runBrowserAccessScenario({ + ...settings, + projectLookupFails: true, + }); + for (const captured of [missing, failed]) { + assert.isDefined(captured); + assert.equal(captured?.browserToolsAvailable, false); + assert.isFalse(captured?.capabilities?.has("device")); + assert.deepEqual(captured?.tools?.servers, []); + assert.deepEqual(captured?.tools?.disabledSkills, ["environment-off", "review"]); + } + assert.deepEqual(failed?.tools, missing?.tools); }), ); @@ -2050,7 +2072,7 @@ it.effect("ProviderSessionManagerV2 fails browser access closed for a missing th projectOverride: true, disabledSkills: ["environment-off"], }; - const healthy = yield* runBrowserAccessScenario({ + const { config: healthy } = yield* runBrowserAccessScenario({ ...environment, toolsOverride: true, projectToolsOverride: false, @@ -2060,24 +2082,36 @@ it.effect("ProviderSessionManagerV2 fails browser access closed for a missing th ["docs"], ); assert.deepEqual(healthy?.tools?.disabledSkills, ["environment-off"]); - const captured = yield* runBrowserAccessScenario({ + const { config: captured } = yield* runBrowserAccessScenario({ ...environment, createThread: false, toolsOverride: true, + projectToolsOverride: false, }); assert.isDefined(captured); assert.equal(captured?.browserToolsAvailable, false); assert.deepEqual(captured?.tools?.disabledSkills, ["environment-off"]); assert.deepEqual(captured?.tools?.servers, []); assert.notEqual(captured?.tools?.fingerprint, healthy?.tools?.fingerprint); - const withoutServers = yield* runBrowserAccessScenario(environment); + const { config: withoutServers } = yield* runBrowserAccessScenario(environment); assert.deepEqual(captured?.tools, withoutServers?.tools); + const { config: restricted, opened } = yield* runBrowserAccessScenario({ + ...environment, + createThread: false, + toolsOverride: true, + }); + assert.isUndefined(restricted); + assert.equal(opened._tag, "Failure"); + if (opened._tag === "Failure") { + assert.equal(opened.failure._tag, "ProviderSessionOpenError"); + assert.instanceOf(opened.failure.cause, ProjectionStore.ProjectionStoreThreadNotFoundError); + } }), ); it.effect("ProviderSessionManagerV2 refuses to start with unavailable tool settings", () => Effect.gen(function* () { - const captured = yield* runBrowserAccessScenario({ + const { config: captured } = yield* runBrowserAccessScenario({ enableAgentBrowserAccess: true, projectOverride: true, toolsOverride: true, @@ -4992,14 +5026,14 @@ it.effect( "ProviderSessionManagerV2 applies project device access independently of browser access", () => Effect.gen(function* () { - const enabled = yield* runBrowserAccessScenario({ + const { config: enabled } = yield* runBrowserAccessScenario({ enableAgentBrowserAccess: false, projectOverride: false, deviceOverride: true, }); assert.isTrue(enabled?.capabilities?.has("device")); assert.isFalse(enabled?.browserToolsAvailable); - const denied = yield* runBrowserAccessScenario({ + const { config: denied } = yield* runBrowserAccessScenario({ enableAgentBrowserAccess: false, projectOverride: false, deviceOverride: true, diff --git a/apps/server/src/orchestration-v2/ProviderSessionManager.ts b/apps/server/src/orchestration-v2/ProviderSessionManager.ts index a3a92981ea942..d19bd8fc9a964 100644 --- a/apps/server/src/orchestration-v2/ProviderSessionManager.ts +++ b/apps/server/src/orchestration-v2/ProviderSessionManager.ts @@ -10,9 +10,9 @@ import { OrchestrationV2RuntimeRequest, ProviderInstanceId, ProviderSessionId, - ServerSettingsError, ThreadId, type ProviderThreadId, + type ProjectId, } from "@t3tools/contracts"; import * as Cause from "effect/Cause"; import * as Clock from "effect/Clock"; @@ -335,8 +335,10 @@ export const layerWithOptions = ( tools: EMPTY_MCP_PROVIDER_SESSION_TOOLS, }; const settings = yield* serverSettings.value.getSettings; + let projectId: ProjectId | null = null; return yield* Effect.gen(function* () { const thread = yield* projectionStore.getThread(threadId); + projectId = thread.projectId; const entries = Object.values(settings.projectSettingsOverrides); const browserOverridden = entries.some( (entry) => entry.enableAgentBrowserAccess !== undefined, @@ -362,18 +364,28 @@ export const layerWithOptions = ( tools: resolveAgentTools(settings, thread.projectId), }; }).pipe( - Effect.catch((cause) => - Effect.logWarning( - "Could not resolve agent access; withholding browser, device and user tools.", + Effect.catch((cause) => { + // Without a project ID, a fallback could enable a project-disabled skill. + if ( + projectId === null && + Object.values(settings.projectSettingsOverrides).some((entry) => + Object.values(entry.disabledSkills ?? {}).some(Boolean), + ) + ) { + return Effect.fail(cause); + } + const effective = resolveProjectSettings(settings, projectId).settings; + return Effect.logWarning( + "Could not resolve agent access; withholding browser, device and user MCP servers.", { threadId, cause }, ).pipe( Effect.as({ browser: false, device: false, - tools: resolveAgentTools({ ...settings, mcpServers: {} }, null), + tools: resolveAgentTools({ ...effective, mcpServers: {} }, null), }), - ), - ), + ); + }), ); }, ); @@ -445,7 +457,10 @@ export const layerWithOptions = ( const prepareMcpSession = ( threadId: ThreadId, providerInstanceId: ProviderInstanceId, - ): Effect.Effect => + ): Effect.Effect< + PreparedMcpCredential, + Effect.Error> + > => options.configureMcp === false ? mcpSessions .clear(threadId) From 5c5cc2deac81b052238e1763ff2dbef98a875fb1 Mon Sep 17 00:00:00 2001 From: Julius Marminge Date: Mon, 19 Oct 2026 19:47:14 +0000 Subject: [PATCH 9/9] fix(claude): keep user MCP secrets out of the CLI environment --- .../Adapters/ClaudeAdapterV2.test.ts | 140 ++++++++++++++++-- .../Adapters/ClaudeAdapterV2.ts | 43 +----- 2 files changed, 133 insertions(+), 50 deletions(-) diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts index f9176e58cf2ed..071a0ab2ed4e2 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.test.ts @@ -688,6 +688,46 @@ describe("ClaudeAdapterV2 MCP query overrides", () => { }), ); assert.notEqual(rotatedKey, initialKey); + const tools = (stdioSecret: string, httpSecret: string, url: string) => ({ + servers: [ + { + name: "command", + transport: { + type: "stdio" as const, + command: "node", + args: ["mcp.js"], + env: [{ name: "API_TOKEN", value: stdioSecret, sensitive: true }], + }, + }, + { + name: "docs", + transport: { + type: "http" as const, + url, + headers: [{ name: "Authorization", value: httpSecret, sensitive: true }], + }, + }, + ], + disabledSkills: [], + fingerprint: "unchanged", + }); + const keyFor = (userTools: McpProviderSession.McpProviderSessionTools) => + ClaudeAdapterV2.claudeEffectiveQueryPolicyKey( + queryPolicy, + ClaudeAdapterV2.claudeMcpQueryOverrides({ + mcpSession: { ...mcpSession, tools: userTools }, + readOnlySandbox: false, + }), + ); + const userKey = keyFor(tools("stdio-token", "http-token", "https://example.com/mcp")); + assert.notEqual(userKey, initialKey); + for (const changed of [ + tools("rotated-stdio", "http-token", "https://example.com/mcp"), + tools("stdio-token", "rotated-http", "https://example.com/mcp"), + tools("stdio-token", "http-token", "https://example.com/other"), + ]) { + assert.notEqual(keyFor(changed), userKey); + } }); it("matches the read-only allowlist to the orchestrator toolkit annotations", () => { @@ -2081,7 +2121,7 @@ describe("ClaudeAdapterV2 MCP credential channel", () => { url: "http://127.0.0.1:43123/mcp", headers: { Authorization: "Bearer dummy-mcp-credential" }, }; - const openWith = (cli: ReturnType) => + const openWith = (cli: ReturnType, protocolEvents: unknown[] = []) => Effect.gen(function* () { const runner = yield* ClaudeAdapterV2.ClaudeAgentSdkQueryRunner; return yield* runner.open({ @@ -2094,7 +2134,47 @@ describe("ClaudeAdapterV2 MCP credential channel", () => { resume: false, cwd: null, environment: { PATH: "/usr/bin" }, - mcpServers: { "t3-code": t3McpServer }, + ...ClaudeAdapterV2.claudeMcpQueryOverrides({ + readOnlySandbox: false, + mcpSession: { + environmentId: EnvironmentId.make("environment-claude-mcp-channel"), + threadId: ThreadId.make("thread-claude-mcp-channel"), + providerSessionId: "mcp-session-claude-mcp-channel", + providerInstanceId: ClaudeAdapterV2.CLAUDE_DEFAULT_INSTANCE_ID, + endpoint: t3McpServer.url, + browserToolsAvailable: true, + authorizationHeader: t3McpServer.headers.Authorization, + tools: { + servers: [ + { + name: "command", + transport: { + type: "stdio", + command: "node", + args: ["mcp.js"], + env: [ + { name: "API_TOKEN", value: "superseded-token", sensitive: true }, + { name: "API_TOKEN", value: "stdin-stdio-secret", sensitive: true }, + ], + }, + }, + { + name: "docs", + transport: { + type: "http", + url: "https://example.com/mcp", + headers: [ + { name: "Authorization", value: "superseded-token", sensitive: true }, + { name: "Authorization", value: "stdin-http-secret", sensitive: true }, + ], + }, + }, + ], + disabledSkills: [], + fingerprint: "stdin-tools", + }, + }, + }), }), pathToClaudeCodeExecutable: "/opt/claude/cli.js", spawnClaudeCodeProcess: cli.spawn, @@ -2102,26 +2182,57 @@ describe("ClaudeAdapterV2 MCP credential channel", () => { }); }).pipe( Effect.provide(ClaudeAdapterV2.layerQueryRunner), - Effect.provideService( - ProviderEventLoggers.ProviderEventLoggers, - ProviderEventLoggers.NoOpProviderEventLoggers, - ), + Effect.provideService(ProviderEventLoggers.ProviderEventLoggers, { + canonical: undefined, + native: { + filePath: "/tmp/claude-mcp-channel-events.log", + write: (event) => + Effect.sync(() => { + protocolEvents.push(event); + }), + close: () => Effect.void, + }, + }), Effect.provide(NodeServices.layer), ); it.effect("sends MCP servers over stdin, not argv or the environment", () => Effect.gen(function* () { const cli = makeFakeClaudeCli(); - const session = yield* openWith(cli); + const protocolEvents: unknown[] = []; + const session = yield* openWith(cli, protocolEvents); yield* session.close; assert.deepInclude(cli.controlRequests, { subtype: "mcp_set_servers", - servers: { "t3-code": t3McpServer }, + servers: { + "t3-code": { ...t3McpServer, timeout: ClaudeAdapterV2.CLAUDE_T3_MCP_TOOL_TIMEOUT_MS }, + command: { + type: "stdio", + command: "node", + args: ["mcp.js"], + env: { API_TOKEN: "stdin-stdio-secret" }, + }, + docs: { + type: "http", + url: "https://example.com/mcp", + headers: { Authorization: "stdin-http-secret" }, + }, + }, }); const spawned = JSON.stringify(cli.spawns); assert.notInclude(spawned, "--mcp-config"); - assert.notInclude(spawned, "dummy-mcp-credential"); + assert.isNotEmpty(protocolEvents); + const logged = JSON.stringify(protocolEvents); + for (const secret of [ + "dummy-mcp-credential", + "stdin-stdio-secret", + "stdin-http-secret", + "superseded-token", + ]) { + assert.notInclude(spawned, secret); + assert.notInclude(logged, secret); + } }), ); @@ -15776,12 +15887,11 @@ describe("ClaudeAdapterV2 user tools", () => { } assert.equal(commandServer.command, "npx"); assert.deepEqual(commandServer.args, ["context7"]); - const materialized = (value: string | undefined) => { - const reference = value?.match(/^\$\{([^}]+)\}$/)?.[1]; - return reference === undefined ? value : openedOptions?.env?.[reference]; - }; - assert.equal(materialized(commandServer.env?.API_TOKEN), "stdio-token"); - assert.equal(materialized(httpServer.headers?.Authorization), "winning-token"); + const environment = JSON.stringify(openedOptions?.env); + assert.notInclude(environment, "stdio-token"); + assert.notInclude(environment, "winning-token"); + assert.equal(commandServer.env?.API_TOKEN, "stdio-token"); + assert.equal(httpServer.headers?.Authorization, "winning-token"); assert.equal(openedOptions?.permissionMode, "default"); assert.isFunction(openedOptions?.canUseTool); assert.include( diff --git a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts index bc1a352459952..3236c405f0b22 100644 --- a/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts +++ b/apps/server/src/orchestration-v2/Adapters/ClaudeAdapterV2.ts @@ -89,7 +89,6 @@ import { type ProviderRequestKind, type ProviderUserInputAnswers, type ProviderThreadId, - type McpServerVariable, type ResolvedMcpServer, type RunId, type ThreadId, @@ -1261,7 +1260,6 @@ export function claudeMcpQueryOverrides(input: { readonly allowedTools?: ReadonlyArray; readonly mcpServers?: ClaudeQueryOptions["mcpServers"]; readonly sdkSettings?: ClaudeSdkSettings; - readonly mcpEnvironment?: Readonly>; } { const session = input.mcpSession; if (session === undefined) { @@ -1277,7 +1275,7 @@ export function claudeMcpQueryOverrides(input: { return { allowedTools: Array.from(new Set([...(input.allowedTools ?? []), ...mcpAllowedTools])), mcpServers: { - ...userServers.mcpServers, + ...userServers, "t3-code": { type: "http", url: session.endpoint, @@ -1299,35 +1297,13 @@ export function claudeMcpQueryOverrides(input: { ), }, }), - ...(Object.keys(userServers.environment).length === 0 - ? {} - : { mcpEnvironment: userServers.environment }), }; } -/** - * The user's servers for `--mcp-config`. A sensitive env value or header becomes a `${VAR}` reference there, and its value goes - * into the child's environment. - */ -function claudeUserMcpServers(servers: ReadonlyArray): { - readonly mcpServers: NonNullable; - readonly environment: Readonly>; -} { - const environment: Record = {}; - const values = (variables: ReadonlyArray) => { - const record = mcpServerVariableRecord(variables); - // A repeated name keeps its last entry, as the record does. - const sensitive = new Map(variables.map((variable) => [variable.name, variable.sensitive])); - for (const name of Object.keys(record)) { - if (sensitive.get(name) !== true) continue; - // Indexed, so two names that read the same once uppercased stay apart. - const reference = `T3_MCP_SECRET_${Object.keys(environment).length}`; - environment[reference] = record[name]!; - record[name] = `\${${reference}}`; - } - return record; - }; - const mcpServers = Object.fromEntries( +function claudeUserMcpServers( + servers: ReadonlyArray, +): NonNullable { + return Object.fromEntries( servers.map((server) => [ server.name, server.transport.type === "stdio" @@ -1335,16 +1311,15 @@ function claudeUserMcpServers(servers: ReadonlyArray): { type: "stdio" as const, command: server.transport.command, args: [...server.transport.args], - env: values(server.transport.env), + env: mcpServerVariableRecord(server.transport.env), } : { type: "http" as const, url: server.transport.url, - headers: values(server.transport.headers), + headers: mcpServerVariableRecord(server.transport.headers), }, ]), ); - return { mcpServers, environment }; } function providerSession(input: { @@ -1986,7 +1961,6 @@ export function claudeEffectiveQueryPolicyKey( readonly allowedTools?: ReadonlyArray; readonly mcpServers?: ClaudeQueryOptions["mcpServers"]; readonly sdkSettings?: ClaudeSdkSettings; - readonly mcpEnvironment?: Readonly>; }, ): string { return JSON.stringify({ @@ -1999,7 +1973,6 @@ export function claudeEffectiveQueryPolicyKey( mcpServers: mcpOverrides.mcpServers, // Skill switches load at process start, so a change reopens the query. sdkSettings: mcpOverrides.sdkSettings, - mcpEnvironment: mcpOverrides.mcpEnvironment, }); } @@ -8597,7 +8570,7 @@ export const makeClaudeAdapterV2 = Effect.fn("makeClaudeAdapterV2")(function* ( cwd: turnInput.runtimePolicy.cwd, attachmentsDir, settings: adapterOptions.settings, - environment: { ...adapterOptions.environment, ...mcpOverrides.mcpEnvironment }, + environment: adapterOptions.environment, tools: queryPolicy.tools ?? CLAUDE_CODE_PRESET_TOOLS, ...(mcpOverrides.allowedTools === undefined ? {}