Evenfire is an intelligence layer platform for running LLM agents that take real actions, on your infrastructure
TypeScript
Merge branch 'feat/mcp-server-oauth-host' into feat/mcp-server-oauth-desktop
Diego Zacariasa93aef8a9acd
diff --cc desktop-app/src/main.tsindex 328826aff,4475fe156..bad38941c--- a/desktop-app/src/main.ts+++ b/desktop-app/src/main.ts@@@ -1,8 -1,8 +1,9 @@@import { BrowserWindow, app, ipcMain, nativeTheme, powerMonitor } from 'electron'import path from 'node:path'import { AppService } from './appService.js'+import { routeClerumOauthCompleted } from './clerumDeepLink.js'import { config } from './config.js'+ import { installDesktopTextContextMenus } from './desktopTextContextMenu.js'import { createEvenfireDeepLinkRouter } from './evenfireDeepLinkRouter.js'import { assertTrustedSender, registerIpcHandlers } from './ipc.js'import { createMainWindowCoordinator, createRetryableInitializer } from './mainWindowCoordinator.js'diff --cc external-rest-api/src/releaseManifest.tsindex 6fac0b56d,127cbd36a..37e2bd371--- a/external-rest-api/src/releaseManifest.ts+++ b/external-rest-api/src/releaseManifest.ts@@@ -8,8 -8,8 +8,8 @@@ export type ReleaseManifest =export const releaseManifest: ReleaseManifest = {releaseId: 'v0.7.0',- externalRestApiVersion: '0.1.80',+ externalRestApiVersion: '0.1.81',- rpcProxyVersion: '0.1.65',+ rpcProxyVersion: '0.1.66',desktopVersion: '0.7.0',minimumDesktopVersion: '0.1.252',}diff --cc host-context-controller/src/mcpAuthorization.test.tsindex 000000000,2af2cc9c1..98471acbamode 000000,100644..100644--- a/host-context-controller/src/mcpAuthorization.test.ts+++ b/host-context-controller/src/mcpAuthorization.test.ts@@@ -1,0 -1,632 +1,651 @@@+ import { describe, expect, it, vi } from 'vitest'+ import type { VerifiedMcpHostPrincipal } from './mcpApiAuthentication'+ import {+ type AuthorityContext,+ type AuthorityHost,+ type AuthorityMcpServer,+ type AuthoritySecret,+ type AuthoritySecretMetadata,- deriveAuthKind,+ McpAuthorizationService,+ type McpAuthorizationStore,++ deriveAuthKind,+ toPublicMcpTransport,+ } from './mcpAuthorization'+ import type { McpServerOAuth } from './types'++ // A complete McpServerOAuth block, shaped like the CRD `spec.oauth` the real+ // producer (k8sClient.readMcpServer) projects — never a hand-built partial.+ const fullOAuth = (grantScope: 'user' | 'context'): McpServerOAuth => ({+ id: 'oauth-adapter',+ provider: 'google',+ clientIdRef: { name: 'oauth-secret', key: 'client-id' },+ clientSecretRef: { name: 'oauth-secret', key: 'client-secret' },+ grantScope,+ })++ const meta = (uid: string, resourceVersion: string) => ({ uid, resourceVersion })+ const principal: VerifiedMcpHostPrincipal = {+ subject: 'mcp-host/standalone',+ hostName: 'host-a',+ hostUid: 'host-uid-a',+ namespace: 'mcp-host',+ jti: 'jti-a',+ issuedAt: 1,+ expiresAt: 4_000_000_000,+ audiences: ['host-context-controller'],+ }+ const principalB: VerifiedMcpHostPrincipal = {+ ...principal,+ hostName: 'host-b',+ hostUid: 'host-uid-b',+ jti: 'jti-b',+ }+ const host: AuthorityHost = {+ name: 'host-a',+ namespace: 'mcp-host',+ metadata: meta('host-uid-a', '10'),+ contextRef: 'context-a',+ }+ const context: AuthorityContext = {+ name: 'context-a',+ namespace: 'mcp-server',+ metadata: meta('context-uid-a', '20'),+ mcpServers: ['server-a'],+ }+ const contextB: AuthorityContext = {+ name: 'context-b',+ namespace: 'mcp-server',+ metadata: meta('context-uid-b', '21'),+ mcpServers: ['server-b'],+ }+ const server: AuthorityMcpServer = {+ name: 'server-a',+ namespace: 'mcp-server',+ metadata: meta('server-uid-a', '30'),+ transport: { type: 'streamableHttp', url: 'http://server-a/mcp' },+ auth: { type: 'bearer', secretRef: 'server-a-auth', secretKey: 'token' },+ enabled: true,+ status: { deployed: true, ready: true, authoritative: false },+ }+ const serverB: AuthorityMcpServer = {+ ...server,+ name: 'server-b',+ metadata: meta('server-uid-b', '31'),+ transport: { type: 'streamableHttp', url: 'http://server-b/mcp' },+ auth: { type: 'bearer', secretRef: 'server-b-auth', secretKey: 'token' },+ }+ const secret: AuthoritySecret = {+ name: 'server-a-auth',+ namespace: 'mcp-server',+ metadata: meta('secret-uid-a', '40'),+ data: { token: Buffer.from('credential-value').toString('base64') },+ }++ class FakeStore implements McpAuthorizationStore {+ secretMetadataReads = 0+ secretValueReads = 0+ secretMetadataSequence: Array<AuthoritySecretMetadata | null> = [secret]+ secretSequence: Array<AuthoritySecret | null> = [secret]+ hostSequence: Array<AuthorityHost | null> | null = null+ contextSequence: Array<AuthorityContext | null> | null = null+ serverSequence: Array<AuthorityMcpServer | null> | null = null+ hostObjects: Map<string, AuthorityHost | null> | null = null+ contextObjects: Map<string, AuthorityContext | null> | null = null+ serverObjects: Map<string, AuthorityMcpServer | null> | null = null+ secretMetadataObjects: Map<string, AuthoritySecretMetadata | null> | null = null+ secretObjects: Map<string, AuthoritySecret | null> | null = null+ hostReads = 0+ contextReads = 0+ serverReads = 0+ hostObject: AuthorityHost | null = host+ contextObject: AuthorityContext | null = context+ serverObject: AuthorityMcpServer | null = server++ async readHost(name: string) {+ this.hostReads += 1+ if (this.hostObjects) return this.hostObjects.get(name) ?? null+ return this.hostSequence+ ? this.hostSequence[Math.min(this.hostReads - 1, this.hostSequence.length - 1)]+ : this.hostObject+ }+ async readContext(name: string) {+ this.contextReads += 1+ if (this.contextObjects) return this.contextObjects.get(name) ?? null+ return this.contextSequence+ ? this.contextSequence[Math.min(this.contextReads - 1, this.contextSequence.length - 1)]+ : this.contextObject+ }+ async readMcpServer(name: string) {+ this.serverReads += 1+ if (this.serverObjects) return this.serverObjects.get(name) ?? null+ return this.serverSequence+ ? this.serverSequence[Math.min(this.serverReads - 1, this.serverSequence.length - 1)]+ : this.serverObject+ }+ async readSecretMetadata(name: string) {+ this.secretMetadataReads += 1+ if (this.secretMetadataObjects) return this.secretMetadataObjects.get(name) ?? null+ const value =+ this.secretMetadataSequence[+ Math.min(this.secretMetadataReads - 1, this.secretMetadataSequence.length - 1)+ ]+ return value ? { name: value.name, namespace: value.namespace, metadata: value.metadata } : null+ }+ async readSecret(name: string) {+ this.secretValueReads += 1+ if (this.secretObjects) return this.secretObjects.get(name) ?? null+ return this.secretSequence[Math.min(this.secretValueReads - 1, this.secretSequence.length - 1)]+ }+ }++ async function expectCredentialFailure(+ service: McpAuthorizationService,+ code: string+ ): Promise<void> {+ const error = await service.getCredential(principal, 'server-a').then(+ () => null,+ reason => reason+ )+ expect(error).toMatchObject({ code })+ expect(error).not.toHaveProperty('token')+ expect(JSON.stringify(error)).not.toContain(+ Buffer.from(secret.data.token, 'base64').toString('utf8')+ )+ }++ describe('McpAuthorizationService', () => {+ it('keeps two Host/Context grant sets disjoint in both directions', async () => {+ const hostB: AuthorityHost = {+ name: 'host-b',+ namespace: 'mcp-host',+ metadata: meta('host-uid-b', '11'),+ contextRef: 'context-b',+ }+ const secretB: AuthoritySecret = {+ name: 'server-b-auth',+ namespace: 'mcp-server',+ metadata: meta('secret-uid-b', '41'),+ data: { token: Buffer.from('credential-b').toString('base64') },+ }+ const store = new FakeStore()+ store.hostObjects = new Map([+ [host.name, host],+ [hostB.name, hostB],+ ])+ store.contextObjects = new Map([+ [context.name, context],+ [contextB.name, contextB],+ ])+ store.serverObjects = new Map([+ [server.name, server],+ [serverB.name, serverB],+ ])+ store.secretMetadataObjects = new Map([+ [secret.name, secret],+ [secretB.name, secretB],+ ])+ store.secretObjects = new Map([+ [secret.name, secret],+ [secretB.name, secretB],+ ])++ const service = new McpAuthorizationService(store)+ await expect(service.listServers(principal)).resolves.toEqual([+ expect.objectContaining({ name: 'server-a' }),+ ])+ await expect(service.listServers(principalB)).resolves.toEqual([+ expect.objectContaining({ name: 'server-b' }),+ ])+ const readsBeforeForeignRequests = {+ secretMetadata: store.secretMetadataReads,+ secretValue: store.secretValueReads,+ }+ await expect(service.getCredential(principal, 'server-b')).rejects.toMatchObject({+ code: 'not_found',+ })+ await expect(service.getCredential(principalB, 'server-a')).rejects.toMatchObject({+ code: 'not_found',+ })+ expect(store.secretMetadataReads).toBe(readsBeforeForeignRequests.secretMetadata)+ expect(store.secretValueReads).toBe(readsBeforeForeignRequests.secretValue)+ await expect(service.getCredential(principalB, 'server-b')).resolves.toMatchObject({+ token: 'credential-b',+ })+ })++ it('projects only valid TCP ports into the public transport contract', () => {+ expect(toPublicMcpTransport({ type: 'streamableHttp', port: 65_535 })).toEqual({+ type: 'streamableHttp',+ port: 65_535,+ })+ for (const port of [0, -1, 65_536, 1.5]) {+ expect(toPublicMcpTransport({ type: 'streamableHttp', port })).toEqual({+ type: 'streamableHttp',+ })+ }+ })++ it('returns only the current Context inventory and an opaque Secret-aware revision', async () => {+ const store = new FakeStore()+ const service = new McpAuthorizationService(store)+ const inventory = await service.listServers(principal)+ expect(inventory).toEqual([+ expect.objectContaining({+ name: 'server-a',+ authRequired: true,+ credentialRevision: expect.any(String),+ status: { deployed: true, ready: true, authoritative: false },+ }),+ ])+ expect(inventory[0]).not.toHaveProperty('contextRef')+ expect(inventory[0]).not.toHaveProperty('auth')+ expect(JSON.stringify(inventory)).not.toContain('credential-value')+ expect(store.secretMetadataReads).toBe(1)+ expect(store.secretValueReads).toBe(0)+ })++ it('authorizes before Secret read and returns the same revision for a stable credential', async () => {+ const store = new FakeStore()+ const service = new McpAuthorizationService(store)+ const inventory = await service.listServers(principal)+ const credential = await service.getCredential(principal, 'server-a')+ expect(credential).toEqual({+ token: 'credential-value',+ credentialRevision: inventory[0].credentialRevision,+ })+ })++ it('performs zero Secret reads for a cross-Context or unknown target', async () => {+ const store = new FakeStore()+ const service = new McpAuthorizationService(store)+ await expect(service.getCredential(principal, 'server-b')).rejects.toMatchObject({+ code: 'not_found',+ })+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })++ it.each(['host', 'context', 'server', 'secret-metadata', 'secret-value'] as const)(+ 'fails closed without disclosing a credential when the %s store read errors',+ async read => {+ const store = new FakeStore()+ if (read === 'host')+ vi.spyOn(store, 'readHost').mockRejectedValueOnce(new Error('read failed'))+ if (read === 'context') {+ vi.spyOn(store, 'readContext').mockRejectedValueOnce(new Error('read failed'))+ }+ if (read === 'server') {+ vi.spyOn(store, 'readMcpServer').mockRejectedValueOnce(new Error('read failed'))+ }+ if (read === 'secret-metadata') {+ vi.spyOn(store, 'readSecretMetadata').mockRejectedValueOnce(new Error('read failed'))+ }+ if (read === 'secret-value') {+ vi.spyOn(store, 'readSecret').mockRejectedValueOnce(new Error('read failed'))+ }+ const service = new McpAuthorizationService(store)++ await expectCredentialFailure(service, 'authorization_unavailable')+ if (read !== 'secret-value') expect(store.secretValueReads).toBe(0)+ if (read === 'host' || read === 'context' || read === 'server') {+ expect(store.secretMetadataReads).toBe(0)+ }+ }+ )++ it.each([+ ['missing secretRef', { auth: { type: 'bearer' as const } }, secret],+ ['missing Secret metadata', {}, null],+ ])('rejects %s before any Secret value read', async (_label, serverOverride, metadataValue) => {+ const store = new FakeStore()+ store.serverObject = { ...server, ...(serverOverride as Partial<AuthorityMcpServer>) }+ store.secretMetadataSequence = metadataValue+ ? [metadataValue as AuthoritySecretMetadata]+ : [null]+ const service = new McpAuthorizationService(store)++ await expectCredentialFailure(service, 'credential_unavailable')+ expect(store.secretValueReads).toBe(0)+ })++ it.each([+ ['missing configured key', { other: Buffer.from('other').toString('base64') }],+ ['empty base64', { token: '' }],+ ['malformed base64', { token: 'invalid-test-token' }],+ ['non-UTF8 base64', { token: Buffer.from([0xff]).toString('base64') }],+ ])('rejects %s without returning Secret data', async (_label, data) => {+ const store = new FakeStore()+ store.secretSequence = [{ ...secret, data }]+ const service = new McpAuthorizationService(store)++ await expectCredentialFailure(service, 'credential_unavailable')+ expect(store.secretValueReads).toBe(1)+ })++ it('uses the same opaque denial for a cross-Context and an unknown target', async () => {+ const store = new FakeStore()+ const service = new McpAuthorizationService(store)+ const denied = await Promise.allSettled([+ service.getCredential(principal, 'server-b'),+ service.getCredential(principal, 'unknown-server'),+ ])+ expect(+ denied.map(result => (result.status === 'rejected' ? result.reason.code : null))+ ).toEqual(['not_found', 'not_found'])+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })++ it('does not read Secret metadata or values for a disabled or deleting server', async () => {+ const store = new FakeStore()+ store.serverObject = { ...server, enabled: false }+ const service = new McpAuthorizationService(store)+ await expect(service.listServers(principal)).resolves.toEqual([])+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'not_found',+ })+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)++ store.serverObject = { ...server, metadata: { ...server.metadata, deletionTimestamp: 'now' } }+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'not_found',+ })+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })++ it('returns a null token without reading a Secret when the server has no auth', async () => {+ const store = new FakeStore()+ store.serverObject = { ...server, auth: { type: 'none' } }+ const service = new McpAuthorizationService(store)+ await expect(service.getCredential(principal, 'server-a')).resolves.toEqual({+ token: null,+ credentialRevision: expect.any(String),+ })+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })++ it('changes the credential revision when the McpServer secretKey changes', async () => {+ const store = new FakeStore()+ store.serverObject = { ...server, auth: { ...server.auth!, secretKey: 'rotated' } }+ store.secretSequence = [+ {+ ...secret,+ data: {+ token: Buffer.from('old').toString('base64'),+ rotated: Buffer.from('new').toString('base64'),+ },+ },+ ]+ store.secretMetadataSequence = [store.secretSequence[0]]+ const service = new McpAuthorizationService(store)+ const first = await service.getCredential(principal, 'server-a')+ store.serverObject = { ...server, auth: { ...server.auth!, secretKey: 'token' } }+ store.secretMetadataReads = 0+ store.secretValueReads = 0+ const second = await service.getCredential(principal, 'server-a')+ expect(first.credentialRevision).not.toBe(second.credentialRevision)+ expect(first.token).toBe('new')+ expect(second.token).toBe('old')+ })++ it('enumerates no foreign server and performs zero Secret reads outside the Context grant', async () => {+ const store = new FakeStore()+ store.contextObject = { ...context, mcpServers: [] }+ const service = new McpAuthorizationService(store)++ await expect(service.listServers(principal)).resolves.toEqual([])+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })++ it('performs zero Secret reads when an old JWT is rebound to a recreated Host name', async () => {+ const store = new FakeStore()+ store.hostObject = { ...host, metadata: meta('replacement-uid', '11') }+ const service = new McpAuthorizationService(store)+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'unauthorized',+ })+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })++ it.each([+ ['missing', null],+ ['deleting', { ...host, metadata: { ...host.metadata, deletionTimestamp: 'now' } }],+ ])('performs zero Secret reads when the authenticated Host is %s', async (_state, value) => {+ const store = new FakeStore()+ store.hostObject = value+ const service = new McpAuthorizationService(store)++ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'unauthorized',+ })+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })++ it.each([+ ['missing', null],+ ['deleting', { ...context, metadata: { ...context.metadata, deletionTimestamp: 'now' } }],+ ])('performs zero Secret reads when the live Context is %s', async (_state, value) => {+ const store = new FakeStore()+ store.contextObject = value+ const service = new McpAuthorizationService(store)++ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'not_found',+ })+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })++ it('discards inventory when the Host binding changes before the response', async () => {+ const store = new FakeStore()+ store.hostSequence = [host, { ...host, metadata: meta('host-uid-a', '11') }]+ const service = new McpAuthorizationService(store)++ await expect(service.listServers(principal)).rejects.toMatchObject({+ code: 'authorization_unavailable',+ })+ expect(store.secretMetadataReads).toBe(1)+ expect(store.secretValueReads).toBe(0)+ })++ it('discards inventory when the Context allowlist changes before the response', async () => {+ const store = new FakeStore()+ store.contextSequence = [+ context,+ { ...context, metadata: meta('context-uid-a', '21'), mcpServers: [] },+ ]+ const service = new McpAuthorizationService(store)++ await expect(service.listServers(principal)).rejects.toMatchObject({+ code: 'authorization_unavailable',+ })+ expect(store.secretMetadataReads).toBe(1)+ expect(store.secretValueReads).toBe(0)+ })++ it('discards a credential when the Secret changes during the post-read fence', async () => {+ const store = new FakeStore()+ store.secretMetadataSequence = [secret, { ...secret, metadata: meta('secret-uid-a', '41') }]+ const service = new McpAuthorizationService(store)+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'authorization_unavailable',+ })+ expect(store.secretMetadataReads).toBe(2)+ expect(store.secretValueReads).toBe(1)+ })++ it('rejects a credential when the Host is rebound during the post-read fence', async () => {+ const store = new FakeStore()+ store.hostSequence = [host, { ...host, metadata: meta('replacement-host-uid', '1') }]+ const service = new McpAuthorizationService(store)++ await expectCredentialFailure(service, 'unauthorized')+ expect(store.secretMetadataReads).toBe(1)+ expect(store.secretValueReads).toBe(1)+ })++ it('rejects a credential when the Context allowlist changes during the post-read fence', async () => {+ const store = new FakeStore()+ store.contextSequence = [context, { ...context, mcpServers: [] }]+ const service = new McpAuthorizationService(store)++ await expectCredentialFailure(service, 'not_found')+ expect(store.secretMetadataReads).toBe(1)+ expect(store.secretValueReads).toBe(1)+ })++ it('discards a credential when the McpServer changes during the post-read fence', async () => {+ const store = new FakeStore()+ store.serverSequence = [server, { ...server, metadata: meta('server-uid-a', '31') }]+ const service = new McpAuthorizationService(store)+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'authorization_unavailable',+ })+ expect(store.secretMetadataReads).toBe(2)+ expect(store.secretValueReads).toBe(1)+ })++ it('fails closed when the McpServer disappears during the post-read fence', async () => {+ const store = new FakeStore()+ store.serverSequence = [server, null]+ const service = new McpAuthorizationService(store)++ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'not_found',+ })+ expect(store.secretMetadataReads).toBe(1)+ expect(store.secretValueReads).toBe(1)+ })++ it('discards a credential when the McpServer is recreated under the same name', async () => {+ const store = new FakeStore()+ store.serverSequence = [server, { ...server, metadata: meta('replacement-server-uid', '1') }]+ const service = new McpAuthorizationService(store)++ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'authorization_unavailable',+ })+ expect(store.secretMetadataReads).toBe(2)+ expect(store.secretValueReads).toBe(1)+ })++ it('fails closed when the Secret disappears during the post-read fence', async () => {+ const store = new FakeStore()+ store.secretMetadataSequence = [secret, null]+ const service = new McpAuthorizationService(store)++ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'authorization_unavailable',+ })+ expect(store.secretMetadataReads).toBe(2)+ expect(store.secretValueReads).toBe(1)+ })++ it('fails closed when the Context disappears during the post-read fence', async () => {+ const store = new FakeStore()+ store.contextSequence = [context, null]+ const service = new McpAuthorizationService(store)+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'not_found',+ })+ expect(store.secretMetadataReads).toBe(1)+ expect(store.secretValueReads).toBe(1)+ })++ it('rejects an expired principal before any Kubernetes authority read', async () => {+ const store = new FakeStore()+ const service = new McpAuthorizationService(store, () => principal.expiresAt)+ await expect(service.getCredential(principal, 'server-a')).rejects.toMatchObject({+ code: 'unauthorized',+ })+ expect(store.secretMetadataReads).toBe(0)+ expect(store.secretValueReads).toBe(0)+ })+ })++ describe('deriveAuthKind (mini-spec 10 §3.1)', () => {+ it.each([- ['oauth + grantScope=user → oauth-user', { type: 'oauth' as const }, { grantScope: 'user' as const }, true, 'oauth-user'],- ['oauth + grantScope=context → oauth-context', { type: 'oauth' as const }, { grantScope: 'context' as const }, true, 'oauth-context'],- ['oauth + grantScope absent → oauth-user (CEL default)', { type: 'oauth' as const }, undefined, true, 'oauth-user'],++ [++ 'oauth + grantScope=user → oauth-user',++ { type: 'oauth' as const },++ { grantScope: 'user' as const },++ true,++ 'oauth-user',++ ],++ [++ 'oauth + grantScope=context → oauth-context',++ { type: 'oauth' as const },++ { grantScope: 'context' as const },++ true,++ 'oauth-context',++ ],++ [++ 'oauth + grantScope absent → oauth-user (CEL default)',++ { type: 'oauth' as const },++ undefined,++ true,++ 'oauth-user',++ ],+ ['bearer (authRequired) → static', { type: 'bearer' as const }, undefined, true, 'static'],+ ['apiKey (authRequired) → static', { type: 'apiKey' as const }, undefined, true, 'static'],+ ['none → undefined (omitted)', { type: 'none' as const }, undefined, false, undefined],+ ['absent auth → undefined', undefined, undefined, false, undefined],+ ])('%s', (_label, auth, oauth, authRequired, expected) => {+ expect(deriveAuthKind(auth as never, oauth as never, authRequired)).toBe(expected)+ })++ it('never collapses an oauth server to static across every grantScope', () => {+ for (const grantScope of ['user', 'context', undefined] as const) {- const kind = deriveAuthKind(- { type: 'oauth' },- grantScope ? { grantScope } : undefined,- true- )++ const kind = deriveAuthKind({ type: 'oauth' }, grantScope ? { grantScope } : undefined, true)+ expect(kind).not.toBe('static')+ expect(kind?.startsWith('oauth-')).toBe(true)+ }+ })++ it('is idempotent: same inputs yield the same authKind', () => {+ const a = deriveAuthKind({ type: 'oauth' }, { grantScope: 'context' }, true)+ const b = deriveAuthKind({ type: 'oauth' }, { grantScope: 'context' }, true)+ expect(a).toBe(b)+ })+ })++ describe('listServers authKind emission (mini-spec 10 §3.2, T1)', () => {+ it.each([+ ['oauth-user', { type: 'oauth' as const }, fullOAuth('user'), 'oauth-user'],+ ['oauth-context', { type: 'oauth' as const }, fullOAuth('context'), 'oauth-context'],- ['static (bearer)', { type: 'bearer' as const, secretRef: 'server-a-auth', secretKey: 'token' }, undefined, 'static'],++ [++ 'static (bearer)',++ { type: 'bearer' as const, secretRef: 'server-a-auth', secretKey: 'token' },++ undefined,++ 'static',++ ],+ ])('emits authKind=%s derived from the real producer', async (_label, auth, oauth, expected) => {+ const store = new FakeStore()+ store.serverObject = {+ ...server,+ auth,+ ...(oauth ? { oauth } : {}),+ }+ const service = new McpAuthorizationService(store)+ const inventory = await service.listServers(principal)+ expect(inventory[0].authKind).toBe(expected)+ // I1: the wire projection never leaks context/auth identity.+ expect(inventory[0]).not.toHaveProperty('contextRef')+ expect(inventory[0]).not.toHaveProperty('auth')+ expect(inventory[0]).not.toHaveProperty('oauth')+ })++ it('omits authKind entirely for a no-auth server', async () => {+ const store = new FakeStore()+ store.serverObject = { ...server, auth: { type: 'none' } }+ const service = new McpAuthorizationService(store)+ const inventory = await service.listServers(principal)+ expect(inventory[0]).not.toHaveProperty('authKind')+ })+ })diff --cc host-context-controller/src/mcpAuthorization.tsindex 000000000,79378bacb..c314a90damode 000000,100644..100644--- a/host-context-controller/src/mcpAuthorization.ts+++ b/host-context-controller/src/mcpAuthorization.ts@@@ -1,0 -1,409 +1,404 @@@+ import { createHash } from 'node:crypto'+ import type { VerifiedMcpHostPrincipal } from './mcpApiAuthentication'-import type {- McpServerAuth,- McpServerOAuth,- McpServerStatus,- McpServerTransport,-} from './types'++import type { McpServerAuth, McpServerOAuth, McpServerStatus, McpServerTransport } from './types'++ export interface AuthorityMetadata {+ uid: string+ resourceVersion: string+ deletionTimestamp?: string+ }++ export interface AuthorityHost {+ name: string+ namespace: string+ metadata: AuthorityMetadata+ contextRef: string+ }++ export interface AuthorityContext {+ name: string+ namespace: string+ metadata: AuthorityMetadata+ mcpServers: readonly string[]+ }++ export interface AuthorityMcpServer {+ name: string+ namespace: string+ metadata: AuthorityMetadata+ description?: string+ transport: McpServerTransport+ auth?: McpServerAuth+ // OAuth broker config (grantScope) from the CRD. Non-secret; used only to+ // derive the inventory `authKind`. HCC never forwards it to mcp-host raw.+ oauth?: McpServerOAuth+ enabled: boolean+ status: McpServerStatus+ }++ export interface AuthoritySecretMetadata {+ name: string+ namespace: string+ metadata: AuthorityMetadata+ }++ export interface AuthoritySecret extends AuthoritySecretMetadata {+ data: Readonly<Record<string, string>>+ }++ export interface McpAuthorizationStore {+ readHost(name: string): Promise<AuthorityHost | null>+ readContext(name: string): Promise<AuthorityContext | null>+ readMcpServer(name: string): Promise<AuthorityMcpServer | null>+ readSecretMetadata(name: string): Promise<AuthoritySecretMetadata | null>+ readSecret(name: string): Promise<AuthoritySecret | null>+ }++ export interface AuthorizedMcpServerInfo {+ name: string+ description?: string+ transport: McpServerTransport+ enabled: boolean+ status: Pick<McpServerStatus, 'deployed' | 'ready'> &+ Partial<Pick<McpServerStatus, 'authoritative'>>+ authRequired: boolean+ credentialRevision?: string+ /**+ * Non-secret credential-mode policy the mcp-host seam dispatches on+ * (mini-spec 10 §3.2). Derived from the CRD auth selector; carries NO+ * authority (no contextRef/secretRef/token). `none` is represented as an+ * omitted field. Absent → mcp-host degrades to `static` (fail-closed).+ */+ authKind?: AuthorizedMcpAuthKind+ }++ export type AuthorizedMcpAuthKind = 'static' | 'oauth-user' | 'oauth-context'++ /**+ * Derive the non-secret `authKind` policy for the inventory (mini-spec 10 §3.1).+ * Pure: same inputs → same output; an oauth server never collapses to `static`.+ * Returns undefined for the implicit `none` (no auth required) so the caller+ * omits the field.+ */+ export function deriveAuthKind(+ auth: McpServerAuth | undefined,+ // Only grantScope is read here; accepting the narrow shape documents the+ // contract and lets callers pass a full McpServerOAuth (structurally wider).+ oauth: Pick<McpServerOAuth, 'grantScope'> | undefined,+ authRequired: boolean+ ): AuthorizedMcpAuthKind | undefined {+ if (auth?.type === 'oauth') {+ return oauth?.grantScope === 'context' ? 'oauth-context' : 'oauth-user'+ }+ return authRequired ? 'static' : undefined+ }++ export interface AuthorizedCredential {+ token: string | null+ credentialRevision: string+ }++ /** Project only the transport keys that are part of the mcp-host wire contract. */+ export function toPublicMcpTransport(transport: McpServerTransport): McpServerTransport {+ return {+ type: transport.type,+ ...(typeof transport.url === 'string' ? { url: transport.url } : {}),+ ...(Number.isSafeInteger(transport.port) &&+ (transport.port ?? 0) > 0 &&+ (transport.port ?? 0) <= 65_535+ ? { port: transport.port }+ : {}),+ }+ }++ export type McpAuthorizationFailureCode =+ | 'unauthorized'+ | 'not_found'+ | 'authorization_unavailable'+ | 'credential_unavailable'++ export class McpAuthorizationError extends Error {+ constructor(readonly code: McpAuthorizationFailureCode) {+ super(code)+ this.name = 'McpAuthorizationError'+ }+ }++ type AuthorizedHostContext = {+ principal: VerifiedMcpHostPrincipal+ host: AuthorityHost+ context: AuthorityContext+ }++ type AuthorizedMcpServerGrant = AuthorizedHostContext & {+ server: AuthorityMcpServer+ secretMetadata: AuthoritySecretMetadata | null+ credentialRevision: string+ }++ const FALLBACK_SECRET_KEYS = ['token', 'api-key', 'apiKey', 'password'] as const++ function isLive(metadata: AuthorityMetadata): boolean {+ return Boolean(metadata.uid && metadata.resourceVersion && !metadata.deletionTimestamp)+ }++ function selectSecretKey(secret: AuthoritySecret | null, configured?: string): string | null {+ if (!secret) return null+ const keys = configured ? [configured] : FALLBACK_SECRET_KEYS+ return (+ keys.find(key => Object.hasOwn(secret.data, key) && typeof secret.data[key] === 'string') ??+ null+ )+ }++ function decodeBase64Credential(value: unknown): string | null {+ if (+ typeof value !== 'string' ||+ value.length === 0 ||+ value.length % 4 !== 0 ||+ !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value)+ ) {+ return null+ }+ const decoded = Buffer.from(value, 'base64')+ if (decoded.length === 0 || decoded.toString('base64') !== value) return null+ const token = decoded.toString('utf8')+ return Buffer.from(token, 'utf8').equals(decoded) && token.length > 0 ? token : null+ }++ function revisionFor(server: AuthorityMcpServer, secret: AuthoritySecretMetadata | null): string {+ const material = JSON.stringify({+ serverUid: server.metadata.uid,+ serverResourceVersion: server.metadata.resourceVersion,+ serverDeleting: server.metadata.deletionTimestamp ?? null,+ authType: server.auth?.type ?? 'none',+ authSecretRef: server.auth?.secretRef ?? null,+ authSecretKey: server.auth?.secretKey ?? null,+ secretUid: secret?.metadata.uid ?? null,+ secretResourceVersion: secret?.metadata.resourceVersion ?? null,+ secretDeleting: secret?.metadata.deletionTimestamp ?? null,+ })+ return createHash('sha256').update(material).digest('base64url')+ }++ function sameHostContext(left: AuthorizedHostContext, right: AuthorizedHostContext): boolean {+ return (+ left.principal.subject === right.principal.subject &&+ left.principal.hostName === right.principal.hostName &&+ left.principal.hostUid === right.principal.hostUid &&+ left.principal.jti === right.principal.jti &&+ left.principal.issuedAt === right.principal.issuedAt &&+ left.principal.expiresAt === right.principal.expiresAt &&+ left.host.name === right.host.name &&+ left.host.namespace === right.host.namespace &&+ left.host.metadata.uid === right.host.metadata.uid &&+ left.host.metadata.resourceVersion === right.host.metadata.resourceVersion &&+ left.host.contextRef === right.host.contextRef &&+ left.context.name === right.context.name &&+ left.context.namespace === right.context.namespace &&+ left.context.metadata.uid === right.context.metadata.uid &&+ left.context.metadata.resourceVersion === right.context.metadata.resourceVersion &&+ left.context.mcpServers.join('\u0000') === right.context.mcpServers.join('\u0000')+ )+ }++ function sameGrant(left: AuthorizedMcpServerGrant, right: AuthorizedMcpServerGrant): boolean {+ return (+ sameHostContext(left, right) &&+ left.server.metadata.uid === right.server.metadata.uid &&+ left.server.metadata.resourceVersion === right.server.metadata.resourceVersion &&+ left.credentialRevision === right.credentialRevision+ )+ }++ export class McpAuthorizationService {+ constructor(+ private readonly store: McpAuthorizationStore,+ private readonly nowEpochSeconds: () => number = () => Math.floor(Date.now() / 1000)+ ) {}++ private assertPrincipalLive(principal: VerifiedMcpHostPrincipal): void {+ if (principal.expiresAt <= this.nowEpochSeconds()) {+ throw new McpAuthorizationError('unauthorized')+ }+ }++ private async resolveHostContext(+ principal: VerifiedMcpHostPrincipal+ ): Promise<AuthorizedHostContext> {+ this.assertPrincipalLive(principal)+ let host: AuthorityHost | null+ let context: AuthorityContext | null+ try {+ host = await this.store.readHost(principal.hostName)+ if (+ !host ||+ host.name !== principal.hostName ||+ host.namespace !== principal.namespace ||+ !isLive(host.metadata) ||+ host.metadata.uid !== principal.hostUid ||+ !host.contextRef+ ) {+ // A missing/recreated/deleting Host invalidates the authenticated+ // principal itself. Surface 401 so mcp-host revokes the whole retained+ // authority set instead of treating this as one missing MCP target.+ throw new McpAuthorizationError('unauthorized')+ }+ context = await this.store.readContext(host.contextRef)+ } catch (error) {+ if (error instanceof McpAuthorizationError) throw error+ throw new McpAuthorizationError('authorization_unavailable')+ }+ if (+ !context ||+ context.name !== host.contextRef ||+ !context.namespace ||+ !isLive(context.metadata)+ ) {+ throw new McpAuthorizationError('not_found')+ }+ return { principal, host, context }+ }++ private async resolveServerGrant(+ binding: AuthorizedHostContext,+ serverName: string+ ): Promise<AuthorizedMcpServerGrant> {+ if (!binding.context.mcpServers.includes(serverName)) {+ throw new McpAuthorizationError('not_found')+ }++ let server: AuthorityMcpServer | null+ try {+ server = await this.store.readMcpServer(serverName)+ } catch {+ throw new McpAuthorizationError('authorization_unavailable')+ }+ if (+ !server ||+ server.name !== serverName ||+ server.namespace !== binding.context.namespace ||+ !server.enabled ||+ !isLive(server.metadata)+ ) {+ throw new McpAuthorizationError('not_found')+ }++ const authRequired = Boolean(server.auth && server.auth.type !== 'none')+ let secretMetadata: AuthoritySecretMetadata | null = null+ if (authRequired && server.auth?.secretRef) {+ try {+ secretMetadata = await this.store.readSecretMetadata(server.auth.secretRef)+ } catch {+ throw new McpAuthorizationError('authorization_unavailable')+ }+ }+ if (+ secretMetadata &&+ (secretMetadata.name !== server.auth?.secretRef ||+ secretMetadata.namespace !== server.namespace ||+ !isLive(secretMetadata.metadata))+ ) {+ secretMetadata = null+ }+ return {+ ...binding,+ server,+ secretMetadata,+ credentialRevision: revisionFor(server, secretMetadata),+ }+ }++ async listServers(principal: VerifiedMcpHostPrincipal): Promise<AuthorizedMcpServerInfo[]> {+ const binding = await this.resolveHostContext(principal)+ const names = [...new Set(binding.context.mcpServers)]+ const servers: AuthorizedMcpServerInfo[] = []+ for (const name of names) {+ let grant: AuthorizedMcpServerGrant+ try {+ grant = await this.resolveServerGrant(binding, name)+ } catch (error) {+ if (error instanceof McpAuthorizationError && error.code === 'not_found') continue+ throw error+ }+ const authRequired = Boolean(grant.server.auth && grant.server.auth.type !== 'none')+ const authKind = deriveAuthKind(grant.server.auth, grant.server.oauth, authRequired)+ servers.push({+ name: grant.server.name,+ ...(grant.server.description ? { description: grant.server.description } : {}),+ transport: toPublicMcpTransport(grant.server.transport),+ enabled: grant.server.enabled,+ status: {+ deployed: grant.server.status.deployed,+ ready: grant.server.status.ready,+ ...(typeof grant.server.status.authoritative === 'boolean'+ ? { authoritative: grant.server.status.authoritative }+ : {}),+ },+ authRequired,+ ...(authRequired ? { credentialRevision: grant.credentialRevision } : {}),+ ...(authKind ? { authKind } : {}),+ })+ }+ const revalidated = await this.resolveHostContext(principal)+ if (!sameHostContext(binding, revalidated)) {+ throw new McpAuthorizationError('authorization_unavailable')+ }+ return servers+ }++ async getCredential(+ principal: VerifiedMcpHostPrincipal,+ serverName: string+ ): Promise<AuthorizedCredential> {+ const binding = await this.resolveHostContext(principal)+ const grant = await this.resolveServerGrant(binding, serverName)+ const authRequired = Boolean(grant.server.auth && grant.server.auth.type !== 'none')+ if (!authRequired) {+ const revalidated = await this.resolveServerGrant(+ await this.resolveHostContext(principal),+ serverName+ )+ if (!sameGrant(grant, revalidated)) {+ throw new McpAuthorizationError('authorization_unavailable')+ }+ this.assertPrincipalLive(principal)+ return { token: null, credentialRevision: grant.credentialRevision }+ }++ if (!grant.server.auth?.secretRef || !grant.secretMetadata) {+ throw new McpAuthorizationError('credential_unavailable')+ }+ let secret: AuthoritySecret | null+ try {+ secret = await this.store.readSecret(grant.server.auth.secretRef)+ } catch {+ throw new McpAuthorizationError('authorization_unavailable')+ }+ if (+ !secret ||+ secret.name !== grant.secretMetadata.name ||+ secret.namespace !== grant.secretMetadata.namespace ||+ !isLive(secret.metadata) ||+ secret.metadata.uid !== grant.secretMetadata.metadata.uid ||+ secret.metadata.resourceVersion !== grant.secretMetadata.metadata.resourceVersion ||+ secret.metadata.deletionTimestamp !== grant.secretMetadata.metadata.deletionTimestamp+ ) {+ throw new McpAuthorizationError('authorization_unavailable')+ }+ const selectedSecretKey = selectSecretKey(secret, grant.server.auth.secretKey)+ if (!selectedSecretKey) throw new McpAuthorizationError('credential_unavailable')+ const token = decodeBase64Credential(secret.data[selectedSecretKey])+ if (!token) throw new McpAuthorizationError('credential_unavailable')++ const revalidated = await this.resolveServerGrant(+ await this.resolveHostContext(principal),+ serverName+ )+ if (!sameGrant(grant, revalidated)) {+ throw new McpAuthorizationError('authorization_unavailable')+ }+ this.assertPrincipalLive(principal)+ return { token, credentialRevision: grant.credentialRevision }+ }+ }diff --cc mcp-host/src/agent/taskExecutor.tsindex 1c534fc6a,15e78e095..7034c8ee4--- a/mcp-host/src/agent/taskExecutor.ts+++ b/mcp-host/src/agent/taskExecutor.ts@@@ -17,11 -18,8 +18,12 @@@ import { LlmError, LlmErrorCode } fromimport { ApprovalController } from '../core/extensions/approvalController'import type { ApprovalConfig } from '../core/extensions/approvalTypes'import { PressureContextManager } from '../core/extensions/contextManager'-import { UnifiedApprovalGateController } from '../core/extensions/mcpApprovalGateController'+import {+ UnifiedApprovalGateController,+ buildConnectRequiredApproval,+ extractConnectRequiredMarker,+} from '../core/extensions/mcpApprovalGateController'+ import { type GuardrailsConfig, buildToolLaneGuardrail } from '../core/guardrails'import type { AgentEventEmitter, LlmPort, LoopController, ToolRegistry } from '../core/interfaces'import { DeferrableToolController } from '../core/orchestration/deferrableToolController'import type { SimpleEventEmitter } from '../core/orchestration/eventEmitter'diff --cc mcp-host/src/contextMapperClient.test.tsindex 61c78e97c,6a8da3626..ed0aae40f--- a/mcp-host/src/contextMapperClient.test.ts+++ b/mcp-host/src/contextMapperClient.test.ts@@@ -61,69 -264,88 +264,92 @@@ describe('ContextMapperClient Host-scop)))- const client = new ContextMapperClient('http://context-mapper.test')+ const client = new ContextMapperClient('http://context-mapper.test', {+ authentication: authentication(),+ })- await expect(client.listServersByContext('production')).resolves.toEqual([])+ await expect(client.pollServers()).rejects.toThrow(+ 'HCC inventory response contains forbidden authority metadata'+ )})- it('does not convert a failed all-server request into an authoritative empty fleet', async () => {- const networkError = new Error('connection reset')- vi.stubGlobal('fetch', vi.fn().mockRejectedValue(networkError))- const client = new ContextMapperClient('http://context-mapper.test')+ it('preserves a valid authKind from the v2 inventory (mini-spec 10 §3.3)', async () => {+ vi.stubGlobal(+ 'fetch',- vi.fn().mockResolvedValue(- new Response(- JSON.stringify(inventory([authorizedServer({ authKind: 'oauth-user' })])),- { status: 200 }++ vi++ .fn()++ .mockResolvedValue(++ new Response(JSON.stringify(inventory([authorizedServer({ authKind: 'oauth-user' })])), {++ status: 200,++ })+ )- )+ )+ const client = new ContextMapperClient('http://context-mapper.test', {+ authentication: authentication(),+ })- await expect(client.listAllServers()).rejects.toBe(networkError)+ const result = await client.pollServers()+ expect(result.servers[0].authKind).toBe('oauth-user')})- it('does not convert an unavailable controller into an authoritative empty fleet', async () => {- // The rejection case above never reaches the `!response.ok` branch, so a- // 503 from an unready controller was uncovered: swapping that throw for- // `return []` left the whole suite green while turning "I cannot tell you"- // into an authoritative "there are none".+ it('rejects an authKind value outside the enum', async () => {vi.stubGlobal('fetch',- vi.fn().mockResolvedValue(- new Response(- JSON.stringify(inventory([authorizedServer({ authKind: 'oauth-admin' })])),- { status: 200 }+ vi+ .fn()- .mockResolvedValue(new Response('', { status: 503, statusText: 'Service Unavailable' }))++ .mockResolvedValue(++ new Response(JSON.stringify(inventory([authorizedServer({ authKind: 'oauth-admin' })])), {++ status: 200,++ })+ )- ))- const client = new ContextMapperClient('http://context-mapper.test')-- await expect(client.listAllServers()).rejects.toThrow(/503/)- })- })+ const client = new ContextMapperClient('http://context-mapper.test', {+ authentication: authentication(),+ })- describe('ContextMapperClient.pollServers', () => {- afterEach(() => {- vi.restoreAllMocks()- vi.unstubAllGlobals()+ await expect(client.pollServers()).rejects.toThrow(+ 'HCC inventory response contains an invalid authKind'+ )})- it('rejects an HTTP 503 instead of fabricating an authoritative empty fleet', async () => {+ it('still rejects forbidden metadata even when a valid authKind is present (guard intact, I1)', async () => {vi.stubGlobal('fetch',-- vi.fn().mockResolvedValue(-- new Response(- JSON.stringify({- error: 'Service Unavailable',- message: 'Context mapper provider inventory is not authoritative',- }),- { status: 503, statusText: 'Service Unavailable' }- JSON.stringify(- inventory([- authorizedServer({ authKind: 'oauth-context', contextRef: 'foreign-context' }),- ])- ),- { status: 200 }++ vi++ .fn()++ .mockResolvedValue(++ new Response(++ JSON.stringify(++ inventory([++ authorizedServer({ authKind: 'oauth-context', contextRef: 'foreign-context' }),++ ])++ ),++ { status: 200 }++ ))-- ))- const client = new ContextMapperClient('http://context-mapper.test')+ const client = new ContextMapperClient('http://context-mapper.test', {+ authentication: authentication(),+ })- await expect(client.pollServers('production')).rejects.toThrow('HTTP 503: Service Unavailable')+ await expect(client.pollServers()).rejects.toThrow(+ 'HCC inventory response contains forbidden authority metadata'+ )})- it('rejects a network failure instead of fabricating an authoritative empty fleet', async () => {- const networkError = new Error('connection reset')- vi.stubGlobal('fetch', vi.fn().mockRejectedValue(networkError))- const client = new ContextMapperClient('http://context-mapper.test')+ it('accepts an authenticated HTTP 200 empty inventory as authoritative', async () => {+ vi.stubGlobal(+ 'fetch',+ vi.fn().mockResolvedValue(new Response(JSON.stringify(inventory([])), { status: 200 }))+ )+ const client = new ContextMapperClient('http://context-mapper.test', {+ authentication: authentication(),+ })- await expect(client.pollServers('production')).rejects.toBe(networkError)+ await expect(client.pollServers()).resolves.toEqual(inventory([]))})- it('bounds a silent HCC request so authoritative polling cannot stall indefinitely', async () => {+ it('bounds a silent authenticated HCC request', async () => {vi.stubGlobal('fetch',vi.fn().mockImplementation((_url: string, init?: RequestInit) => {diff --cc mcp-host/src/core/orchestration/toolUseLoopToolBatch.tsindex 428a95599,43edd09b1..bba81bb71--- a/mcp-host/src/core/orchestration/toolUseLoopToolBatch.ts+++ b/mcp-host/src/core/orchestration/toolUseLoopToolBatch.ts@@@ -1,8 -1,11 +1,15 @@@+ import { randomUUID } from 'crypto'import { extractToolIntent, getDisplayName } from '../../progress/intentExtraction.js'+import {+ buildConnectRequiredApproval,+ extractConnectRequiredMarker,+} from '../extensions/mcpApprovalGateController'+ import {+ type ToolIdentity,+ recordAndCheck,+ recordDecision,+ resolveToolIdentityFromRegistry,+ } from '../guardrails'import type { ChatMessage, PendingApproval, TokenUsage, ToolCall, ToolResult } from '../types'import type { LoopConfig } from './loopConfig'import { executeSingleTool, reportToolComplete, reportToolStart } from './toolUseLoopSingleTool'@@@ -256,10 -391,23 +395,25 @@@ export async function executeToolCalls}const progressStart = reportToolStart(config, call, iteration, i, calls.length, llmTextContent)- const toolResult = await executeSingleTool(call, config, iteration)+ let toolResult = await executeSingleTool(call, config, iteration)++ // PostToolUse redaction (spec §6.2 / §10 #3): installed `post_tool_use` hooks+ // may redact the model-visible result `content` (never `is_error`). Only the+ // LLM-message `content` is touched — `rawContent` (UI preview) is left intact.++ // Applied here — before the abort push, the U5 connect-required suspend, and++ // the main push below — so every downstream consumer sees the redacted result.+ if (config.guardrails?.transformResult && toolIdentity) {+ const view = await config.guardrails.transformResult(toolIdentity, call.arguments, {+ content: toolResult.content,+ isError: toolResult.is_error,+ })+ if (view.content !== toolResult.content) {+ toolResult = { ...toolResult, content: view.content }+ }+ }- toolResults.push(toolResult)if (config.abortSignal?.aborted) {+ toolResults.push(toolResult)return { toolResults, cancelled: true }}diff --cc mcp-host/src/main.tsindex 9aa43190d,5ce8ac4ce..f042a1034--- a/mcp-host/src/main.ts+++ b/mcp-host/src/main.ts@@@ -80,7 -84,15 +84,15 @@@ importreplaceAuthoritativeMcpFleet,runAuthoritativeMcpInitialization,} from './mcp/authoritativeFleet'-import { type BrokerTokenProviderDeps, createBrokerTokenProvider } from './mcp/brokerTokenProvider'+ import {+ createMcpAuthorityStalenessDeadline,+ handleMcpAuthorityPollFailure,+ isMcpAuthorityStale,+ revokeMcpAuthorityState,+ } from './mcp/authorityLifecycle'+ import type { HandleMcpAuthorityPollFailureOptions } from './mcp/authorityLifecycle'+import { type BrokerTokenProviderDeps, createBrokerTokenProvider } from './mcp/brokerTokenProvider'+ import { McpStatusHeartbeat } from './mcp/statusHeartbeat'import { startMcpInitializationInBackground } from './mcpBackgroundInit'import { IncomingMessageHandler, PendingTaskEntry } from './messageHandler'import {diff --cc mcp-host/src/mcp/__tests__/authorityLifecycle.test.tsindex 000000000,30d2a525f..451cffab2mode 000000,100644..100644--- a/mcp-host/src/mcp/__tests__/authorityLifecycle.test.ts+++ b/mcp-host/src/mcp/__tests__/authorityLifecycle.test.ts@@@ -1,0 -1,372 +1,376 @@@+ import { afterEach, describe, expect, it, vi } from 'vitest'+ import { ContextMapperClient, ContextMapperRequestError } from '../../contextMapperClient'+ import type { McpServerInfo } from '../../types'+ import { AuthoritativeMcpFleetCoordinator } from '../authoritativeFleet'+ import {+ createMcpAuthorityStalenessDeadline,+ handleMcpAuthorityPollFailure,+ revokeMcpAuthorityState,+ } from '../authorityLifecycle'+ import { McpClient } from '../client'+ import { McpManager, SHARED_PRINCIPAL, serializeClientKey } from '../manager'++ const securedServer: McpServerInfo = {+ name: 'secured-server',+ transport: { type: 'streamableHttp', url: 'http://secured-server.test/mcp' },+ enabled: true,+ authRequired: true,+ credentialRevision: 'credential-revision-1',+ status: { deployed: true, ready: true, authoritative: true },+ }++ function deferred(): { promise: Promise<void>; resolve(): void } {+ let resolve!: () => void+ const promise = new Promise<void>(resolvePromise => {+ resolve = resolvePromise+ })+ return { promise, resolve }+ }++ function retainedClient(+ manager: McpManager,+ serverName = securedServer.name+ ): McpClient | undefined {+ return (+ manager as unknown as {+ clients: Map<string, McpClient>+ }+ ).clients.get(serializeClientKey(serverName, SHARED_PRINCIPAL))+ }++ function pendingClient(+ manager: McpManager,+ serverName = securedServer.name+ ): McpClient | undefined {+ return (+ manager as unknown as {+ pendingAdmissions: Map<string, { client: McpClient }>+ }+ ).pendingAdmissions.get(serializeClientKey(serverName, SHARED_PRINCIPAL))?.client+ }++ function createLifecycleHarness(+ manager: McpManager,+ coordinator = new AuthoritativeMcpFleetCoordinator(1, 1, true)+ ) {+ let currentManager: McpManager | null = manager+ let serverState = new Map([[securedServer.name, 'credential-revision-1']])+ let lastSuccessAt = 10_000+ let generation = 7+ let pollerRunning = true+ let clearDeadline: () => void = () => undefined+ const effects: string[] = []+ const reasons: string[] = []++ const originalCloseManager = coordinator.closeManager.bind(coordinator)+ vi.spyOn(coordinator, 'closeManager').mockImplementation(closingManager => {+ effects.push('coordinator-close')+ originalCloseManager(closingManager)+ })+ const originalScheduleCleanup = coordinator.scheduleCleanup.bind(coordinator)+ vi.spyOn(coordinator, 'scheduleCleanup').mockImplementation(cleanup => {+ effects.push('cleanup-scheduled')+ originalScheduleCleanup(cleanup)+ })+ const originalManagerClose = manager.close.bind(manager)+ vi.spyOn(manager, 'close').mockImplementation(scheduleCleanup => {+ effects.push('manager-close')+ return originalManagerClose(scheduleCleanup)+ })++ const revoke = (reason: string, restartPolling: boolean): void => {+ reasons.push(reason)+ revokeMcpAuthorityState({+ reason,+ restartPolling,+ invalidateInitialization: () => {+ effects.push('generation-invalidated')+ generation += 1+ },+ stopPolling: () => {+ effects.push('polling-stopped')+ pollerRunning = false+ },+ clearStalenessDeadline: () => {+ effects.push('deadline-cleared')+ clearDeadline()+ },+ withdrawManager: () => {+ effects.push('manager-withdrawn')+ const closingManager = currentManager+ currentManager = null+ return closingManager+ },+ clearServerState: () => {+ effects.push('server-state-cleared')+ serverState = new Map()+ },+ clearLastSuccess: () => {+ effects.push('last-success-cleared')+ lastSuccessAt = 0+ },+ coordinator,+ onCleanupFailure: () => effects.push('cleanup-failed'),+ onRevoked: () => effects.push('revoked'),+ shouldRestartPolling: () => true,+ startPolling: () => {+ effects.push('polling-started')+ pollerRunning = true+ },+ })+ }++ return {+ coordinator,+ effects,+ reasons,+ revoke,+ setDeadlineClear: (clear: () => void) => {+ clearDeadline = clear+ },+ state: () => ({+ currentManager,+ serverState,+ lastSuccessAt,+ generation,+ pollerRunning,+ }),+ }+ }++ async function captureError(effect: () => Promise<unknown>): Promise<unknown> {+ try {+ await effect()+ } catch (error) {+ return error+ }+ throw new Error('Expected operation to reject')+ }++ describe('MCP authority lifecycle', () => {+ afterEach(() => {+ vi.restoreAllMocks()+ vi.unstubAllGlobals()+ vi.useRealTimers()+ })++ it.each([+ { status: 401 as const, expectedFetches: 2, expectedRefreshes: 1 },+ { status: 403 as const, expectedFetches: 1, expectedRefreshes: 0 },+ ])(+ 'withdraws the live fleet synchronously and restarts polling after persistent $status',+ async ({ status, expectedFetches, expectedRefreshes }) => {+ vi.spyOn(McpClient.prototype, 'connect').mockImplementation(async function (this: McpClient) {+ // Mimic the real connect's JIT token resolution so the post-revoke wipe+ // assertion below exercises currentAuthToken.+ ;(this as unknown as { currentAuthToken?: string }).currentAuthToken = await (+ this as unknown as { tokenProvider?: { resolve(): Promise<string | undefined> } }+ ).tokenProvider?.resolve()+ ;(this as unknown as { connected: boolean }).connected = true+ })+ const manager = new McpManager()+ await manager.addServer(securedServer, 'sensitive-upstream-bearer')+ const installedClient = retainedClient(manager)+ expect(installedClient).toBeDefined()++ const harness = createLifecycleHarness(manager)+ harness.coordinator.publishSnapshot(manager, [securedServer])+ const refresh = vi.fn().mockResolvedValue(undefined)+ const fetchMock = vi.fn().mockResolvedValue(new Response(null, { status }))+ vi.stubGlobal('fetch', fetchMock)+ const client = new ContextMapperClient('http://context-mapper.test', {+ authentication: {+ getAccessToken: () => 'host-access-token',+ refreshOnUnauthorized: refresh,+ onCallerAuthorizationFailure: rejectedStatus =>+ harness.revoke(`caller_${rejectedStatus}`, true),+ },+ })++ const error = await captureError(() => client.pollServers())+ expect(error).toBeInstanceOf(ContextMapperRequestError)+ const disposition = handleMcpAuthorityPollFailure(error, {+ hasPublishedManager: () => harness.state().currentManager !== null,+ lastSuccessAt: () => harness.state().lastSuccessAt,+ now: () => 70_000,+ maxStalenessMs: 60_000,+ revoke: harness.revoke,+ onCallerAuthorizationRejected: vi.fn(),+ onInventoryAuthorityRevoked: vi.fn(),+ onUnavailable: vi.fn(),+ })++ expect(disposition).toBe('caller_authorization_rejected')+ expect(fetchMock).toHaveBeenCalledTimes(expectedFetches)+ expect(refresh).toHaveBeenCalledTimes(expectedRefreshes)+ expect(harness.reasons).toEqual([`caller_${status}`])+ expect(harness.state()).toMatchObject({+ currentManager: null,+ lastSuccessAt: 0,+ generation: 8,+ pollerRunning: true,+ })+ expect(harness.state().serverState.size).toBe(0)- expect((installedClient as unknown as { currentAuthToken?: string }).currentAuthToken).toBeUndefined()++ expect(++ (installedClient as unknown as { currentAuthToken?: string }).currentAuthToken++ ).toBeUndefined()+ expect(manager.getConnectedServers()).toEqual([])+ expect(manager.getKnownServers()).toEqual([])+ expect(harness.effects).toEqual([+ 'generation-invalidated',+ 'polling-stopped',+ 'deadline-cleared',+ 'manager-withdrawn',+ 'server-state-cleared',+ 'last-success-cleared',+ 'coordinator-close',+ 'manager-close',+ 'cleanup-scheduled',+ 'revoked',+ 'polling-started',+ ])+ await expect(manager.addServer(securedServer, 'new-bearer')).resolves.toBe('stale')+ await harness.coordinator.drainCleanups()+ }+ )++ it('classifies an actual inventory 404 as complete authority revocation', async () => {+ const manager = new McpManager()+ const harness = createLifecycleHarness(manager)+ harness.coordinator.publishSnapshot(manager, [securedServer])+ vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(null, { status: 404 })))+ const client = new ContextMapperClient('http://context-mapper.test', {+ authentication: {+ getAccessToken: () => 'host-access-token',+ refreshOnUnauthorized: vi.fn(),+ onCallerAuthorizationFailure: vi.fn(),+ },+ })+ const error = await captureError(() => client.pollServers())+ const inventoryRevoked = vi.fn()++ const disposition = handleMcpAuthorityPollFailure(error, {+ hasPublishedManager: () => harness.state().currentManager !== null,+ lastSuccessAt: () => harness.state().lastSuccessAt,+ now: () => 70_000,+ maxStalenessMs: 60_000,+ revoke: harness.revoke,+ onCallerAuthorizationRejected: vi.fn(),+ onInventoryAuthorityRevoked: inventoryRevoked,+ onUnavailable: vi.fn(),+ })++ expect(disposition).toBe('inventory_not_found')+ expect(inventoryRevoked).toHaveBeenCalledTimes(1)+ expect(harness.reasons).toEqual(['inventory_not_found'])+ expect(harness.state()).toMatchObject({ currentManager: null, pollerRunning: true })+ await harness.coordinator.drainCleanups()+ })++ it('revokes the full state at the absolute staleness deadline and restarts recovery polling', () => {+ vi.useFakeTimers()+ vi.setSystemTime(new Date('2026-08-20T00:00:00.000Z'))+ const manager = new McpManager()+ const harness = createLifecycleHarness(manager)+ harness.coordinator.publishSnapshot(manager, [securedServer])+ const deadline = createMcpAuthorityStalenessDeadline(60_000, () =>+ harness.revoke('authority_stale_deadline', true)+ )+ harness.setDeadlineClear(deadline.clear)++ deadline.recordSuccess()+ vi.advanceTimersByTime(60_000)++ expect(harness.reasons).toEqual(['authority_stale_deadline'])+ expect(harness.state()).toMatchObject({+ currentManager: null,+ lastSuccessAt: 0,+ generation: 8,+ pollerRunning: true,+ })+ expect(harness.state().serverState.size).toBe(0)+ })++ it('revokes an unavailable stale fleet through the poll-error path', async () => {+ const manager = new McpManager()+ const harness = createLifecycleHarness(manager)+ harness.coordinator.publishSnapshot(manager, [securedServer])+ const unavailable = vi.fn()++ const disposition = handleMcpAuthorityPollFailure(new Error('transport unavailable'), {+ hasPublishedManager: () => harness.state().currentManager !== null,+ lastSuccessAt: () => harness.state().lastSuccessAt,+ now: () => 70_000,+ maxStalenessMs: 60_000,+ revoke: harness.revoke,+ onCallerAuthorizationRejected: vi.fn(),+ onInventoryAuthorityRevoked: vi.fn(),+ onUnavailable: unavailable,+ })++ expect(disposition).toBe('authority_stale')+ expect(unavailable).toHaveBeenCalledTimes(1)+ expect(harness.reasons).toEqual(['authority_stale'])+ expect(harness.state()).toMatchObject({ currentManager: null, pollerRunning: true })+ await harness.coordinator.drainCleanups()+ })++ it('fences a delayed admission so revocation cannot republish its bearer or tools', async () => {+ const connectStarted = deferred()+ const releaseConnect = deferred()+ vi.spyOn(McpClient.prototype, 'connect').mockImplementation(async function (this: McpClient) {+ // Mimic the real connect's JIT token resolution before the transport pause+ // so the fencing assertions (bearer held, then wiped) observe it.+ ;(this as unknown as { currentAuthToken?: string }).currentAuthToken = await (+ this as unknown as { tokenProvider?: { resolve(): Promise<string | undefined> } }+ ).tokenProvider?.resolve()+ connectStarted.resolve()+ await releaseConnect.promise+ if ((this as unknown as { retired: boolean }).retired) {+ throw new Error('MCP client is closed')+ }+ ;(this as unknown as { connected: boolean }).connected = true+ })+ const manager = new McpManager()+ const coordinator = new AuthoritativeMcpFleetCoordinator(1, 1, true)+ const lease = coordinator.publishSnapshot(manager, [securedServer])+ const harness = createLifecycleHarness(manager, coordinator)+ const committed = vi.fn()+ let outcome: string | undefined+ const admission = coordinator.runAdmission(+ manager,+ securedServer.name,+ lease,+ async isCurrent => {+ outcome = await manager.addServer(securedServer, 'late-sensitive-bearer', {+ isCurrent,+ onCommit: committed,+ scheduleCleanup: cleanup => coordinator.scheduleCleanup(cleanup),+ })+ }+ )++ await connectStarted.promise+ const candidate = pendingClient(manager)+ expect(candidate).toBeDefined()- expect((candidate as unknown as { currentAuthToken?: string }).currentAuthToken).toBe('late-sensitive-bearer')++ expect((candidate as unknown as { currentAuthToken?: string }).currentAuthToken).toBe(++ 'late-sensitive-bearer'++ )++ harness.revoke('caller_403', true)++ expect(harness.state().currentManager).toBeNull()+ expect((candidate as unknown as { currentAuthToken?: string }).currentAuthToken).toBeUndefined()+ expect(manager.getConnectedServers()).toEqual([])+ expect(manager.getKnownServers()).toEqual([])+ releaseConnect.resolve()+ await admission+ await coordinator.drainCleanups()++ expect(outcome).toBe('stale')+ expect(committed).not.toHaveBeenCalled()+ expect(manager.getAllTools()).toEqual([])+ expect(manager.getConnectedServers()).toEqual([])+ expect(harness.state().currentManager).toBeNull()+ })+ })diff --cc mcp-host/src/mcp/__tests__/authorizationRevocation.test.tsindex 000000000,39c526a8b..451ac9292mode 000000,100644..100644--- a/mcp-host/src/mcp/__tests__/authorizationRevocation.test.ts+++ b/mcp-host/src/mcp/__tests__/authorizationRevocation.test.ts@@@ -1,0 -1,31 +1,29 @@@+ import { describe, expect, it } from 'vitest'+ import type { McpServerInfo } from '../../types'+ import { McpClient, staticTokenProvider } from '../client'++ const server: McpServerInfo = {+ name: 'scoped-server',+ transport: { type: 'streamableHttp', url: 'http://scoped-server.test/mcp' },+ enabled: true,+ authRequired: true,+ credentialRevision: 'credential-revision-1',+ status: { deployed: true, ready: true },+ }++ describe('MCP credential revocation', () => {+ it('wipes the retained bearer synchronously when a client is retired', async () => {+ const client = new McpClient(server, staticTokenProvider('sensitive-upstream-bearer'))+ // Simulate a live connection: connect() resolves the provider into+ // currentAuthToken, which retire() must clear synchronously. Seed it+ // directly so the assertion exercises retire()'s wipe, not the unconnected+ // (already-undefined) state.+ ;(client as unknown as { currentAuthToken?: string }).currentAuthToken =+ 'sensitive-upstream-bearer'++ const cleanup = client.retire()+- expect(- (client as unknown as { currentAuthToken?: string }).currentAuthToken- ).toBeUndefined()++ expect((client as unknown as { currentAuthToken?: string }).currentAuthToken).toBeUndefined()+ await expect(cleanup()).resolves.toBeUndefined()+ })+ })diff --cc mcp-host/src/mcp/client.tsindex 80185879f,bae29aa0b..ec53d8616--- a/mcp-host/src/mcp/client.ts+++ b/mcp-host/src/mcp/client.ts@@@ -5,13 -5,19 +5,19 @@@import { Client } from '@modelcontextprotocol/sdk/client/index.js'import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js'import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'+ import { ListToolsResultSchema } from '@modelcontextprotocol/sdk/types.js'import { McpServerInfo, McpTool } from '../types'-import { extractStructuredHttpStatus, isAuthError } from './serverStatus'+ import {+ type McpToolCallOptions,+ ensureNotAborted,+ remainingBudgetMs,+ requestOptions,+ resolveMcpRequestTimeoutMs,+ withRequestTimeout,+ } from './requestOptions'+import { extractStructuredHttpStatus, isAuthError } from './serverStatus'- const DEFAULT_MCP_TOOL_TIMEOUT_MS = 3_600_000- const DEFAULT_MCP_TOOL_MAX_TOTAL_TIMEOUT_MS = 3_600_000- const MCP_TOOL_TIMEOUT_ENV = 'CLERUM_MCP_TOOL_TIMEOUT_MS'- const MCP_TOOL_MAX_TOTAL_TIMEOUT_ENV = 'CLERUM_MCP_TOOL_MAX_TOTAL_TIMEOUT_MS'+ export type { McpToolCallOptions } from './requestOptions'type SupportedMcpTransport = SSEClientTransport | StreamableHTTPClientTransport@@@ -63,12 -59,7 +59,6 @@@ export class McpAuthError extends Erro}}- interface McpSdkRequestOptions {- timeout: number- maxTotalTimeout: number- signal?: AbortSignal- }--interface McpCallRecovery {sourceEpoch: numbersourceClient: Client