@reclaimprotocol/agent 0.1.4 → 0.1.6

package/src/mcp/tools/agent/propose.ts

@@ -1,120 +1,128 @@
-import { randomUUID } from 'node:crypto'
-import { draftProvider } from '../../../provider/draft.ts'
+/**
+ * `propose_provider` — draft a provider (recipe + captured secrets) from ONE
+ * captured request, one match + redaction per target value. Authored once as a
+ * plain {@link RegisteredTool}; hosts pass their own backend resolver. The
+ * draft (recipe + real secret header values) is held server-side under an
+ * opaque `draftId`; the result carries only the secret-free provider.
+ */
+import { objectSchema, type ResolveBackend } from '../../../authoring/util.ts'
+import { draftProvider, type DraftTarget } from '../../../provider/draft.ts'
 import { OPRF_MAX_BYTES } from '../../../provider/matcher.ts'
 import type { OprfMode } from '../../../provider/schema.ts'
 import { verificationWarnings } from '../../../provider/verification-checks.ts'
-import { defineTool, type RegisteredTool } from '../../server.ts'
-import type { CaptureStore } from './capture.ts'
+import { defineTool, type RegisteredTool } from '../../../tools/registry.ts'
 
-export interface SecretStore {
-	put: (values: Record<string, string>) => string
-	resolve: (ref: string) => Record<string, string> | undefined
-	clear: () => void
-}
-
-export function makeSecretStore(): SecretStore {
-	const map = new Map<string, Record<string, string>>()
-	return {
-		put: (values) => {
-			const id = `sref_${randomUUID()}`
-			map.set(id, values)
-			return id
-		},
-		resolve: (ref) => map.get(ref),
-		clear: () => map.clear(),
-	}
-}
-
-export function proposeTool(
-	captures: CaptureStore,
-	secrets: SecretStore,
-): RegisteredTool {
-	return defineTool<{
-		captureId: string
-		requestId: string
-		target: string
-		name: string
-		hash?: OprfMode
-	}>(
+export function proposeTool(resolveBackend: ResolveBackend): RegisteredTool {
+	return defineTool<Record<string, unknown>>(
 		{
 			name: 'propose_provider',
 			description:
-				'Draft a Reclaim provider JSON from a captured request + ' +
-				'a target value. ' +
-				'Secret header values are stored server-side and replaced with an ' +
-				'opaque secretParamsRef ' +
-				'in the response — raw secret values never appear in tool output. ' +
-				"`hash` is opt-in: when set, the captured value is OPRF'd so " +
-				'the attestor never sees ' +
-				'cleartext. Skill should ask the dev first. `oprf-raw` ' +
-				'is the only variant that runs ' +
-				'without external deps; `oprf` needs gnark (Linux/macOS), ' +
-				'`oprf-mpc` needs a TEE attestor. ' +
-				'The response may include `verificationWarnings` — advisory ' +
-				'author-only decisions (e.g. a user-specific URL part needing ' +
-				'the {{context.<name>}}-vs-bare call). Surface each to the ' +
-				'dev verbatim and resolve before publishing.',
-			inputSchema: {
-				type: 'object',
-				properties: {
-					captureId: { type: 'string' },
+				'Draft a provider from ONE captured request. Pass `targets` (an '
+				+ 'array): one entry per value to extract, each with its `value` '
+				+ '(verbatim) and a distinct `name` (its param). The provider gets '
+				+ 'one match + redaction per target. Returns a draftId + recipe '
+				+ '(never secrets). Prefer a SINGLE request holding ALL values. '
+				+ 'Single-value shorthand: `target` + `name`. Per-target `hash` '
+				+ 'OPRF-hashes that value.',
+			inputSchema: objectSchema(
+				{
 					requestId: { type: 'string' },
-					target: { type: 'string' },
 					name: { type: 'string' },
+					targets: {
+						type: 'array',
+						items: {
+							type: 'object',
+							properties: {
+								value: { type: 'string' },
+								name: { type: 'string' },
+								hash: {
+									type: 'string',
+									enum: ['oprf-raw', 'oprf', 'oprf-mpc'],
+								},
+							},
+							required: ['value', 'name'],
+						},
+					},
+					target: { type: 'string' },
 					hash: { type: 'string', enum: ['oprf-raw', 'oprf', 'oprf-mpc'] },
 				},
-				required: ['captureId', 'requestId', 'target', 'name'],
-			},
+				['requestId', 'name'],
+			),
 		},
-		async({ captureId, requestId, target, name, hash }) => {
-			if(hash !== undefined && target.length > OPRF_MAX_BYTES) {
+		async(args) => {
+			const backend = resolveBackend(args)
+			const requestId = String(args.requestId)
+			const providerName = String(args.name)
+			const defaultHash = args.hash as OprfMode | undefined
+
+			// Explicit multi-value `targets`, else the single `target` shorthand.
+			const raw = Array.isArray(args.targets) ? args.targets : []
+			const targets: DraftTarget[] = raw.length
+				? raw.map((t) => {
+					const o = t as Record<string, unknown>
+					return {
+						value: String(o.value),
+						name: String(o.name),
+						...(typeof o.hash === 'string'
+							? { hash: o.hash as OprfMode }
+							: {}),
+					}
+				})
+				: typeof args.target === 'string'
+					? [{
+						value: args.target,
+						name: providerName,
+						...(defaultHash ? { hash: defaultHash } : {}),
+					}]
+					: []
+			if(targets.length === 0) {
 				throw new Error(
-					`OPRF caps hashed values at ${OPRF_MAX_BYTES} bytes; ` +
-					`got ${target.length}-byte target ` +
-					`"${target}". Try a tighter target ` +
-					'(e.g. just the relevant substring) or call ' +
-						'propose_provider without `hash`.',
+					'propose_provider needs a `target` value or a non-empty '
+					+ '`targets` array',
 				)
 			}
 
-			const session = captures.sessions.get(captureId)
-			if(!session) {
-				throw new Error(`no capture ${captureId}`)
+			for(const t of targets) {
+				if((t.hash ?? defaultHash) !== undefined
+					&& t.value.length > OPRF_MAX_BYTES) {
+					throw new Error(
+						`OPRF caps hashed values at ${OPRF_MAX_BYTES} bytes; got `
+						+ `${t.value.length}-byte "${t.value}". Use a tighter `
+						+ 'target or drop `hash`.',
+					)
+				}
 			}
 
-			const r = session.requests.get(requestId)
-			if(!r) {
-				throw new Error(`no request ${requestId}`)
+			const captured = backend.capture.requests.get(requestId)
+			if(!captured) {
+				throw new Error(`no captured request ${requestId}`)
 			}
 
-			const body = session.bodies.get(requestId)
-			if(!body.available) {
-				throw new Error(`request body unavailable: ${body.reason}`)
+			if(!captured.responseBody) {
+				throw new Error(`request body unavailable for ${requestId}`)
 			}
 
-			const reqWithBody = { ...r, responseBody: body.body }
-			const { provider, secretRefs } = draftProvider(
-				reqWithBody,
-				target,
-				name,
-				hash,
+			const { provider, secretRefs, extractions } = draftProvider(
+				captured, targets, providerName, defaultHash,
 			)
-
-			// Stash real secret values for later replay/proof.
-			const realSecrets: Record<string, string> = {}
+			// Materialize the real secret header values for later replay/prove;
+			// they stay in the server-side draft, never in this result.
+			const secrets: Record<string, string> = {}
 			for(const ref of secretRefs) {
-				const real = r.requestHeaders[ref.name]
+				const real = captured.requestHeaders[ref.name]
 				if(real !== undefined) {
-					realSecrets[ref.name] = real
+					secrets[ref.name] = real
 				}
 			}
 
-			const secretParamsRef = secrets.put(realSecrets)
+			const draftId = backend.drafts.put({
+				provider, secretRefs, secrets, requestId, extractions,
+			})
 			const warnings = verificationWarnings(provider)
 			return {
+				draftId,
 				provider,
 				secretRefs,
-				secretParamsRef,
 				...(warnings.length ? { verificationWarnings: warnings } : {}),
 			}
 		},

package/src/mcp/tools/agent/publish.ts

@@ -129,7 +129,7 @@ export function createVersionFromCaptureTool(
 		{
 			name: 'create_provider_version_from_capture',
 			description:
-				'Persist drafted ReclaimProvider(s) as a verification version. ' +
+				'Persist drafted ReclaimProvider(s) as a provider version. ' +
 				'Call this after run_proof succeeds, passing the `provider` ' +
 				'object(s) from propose_provider VERBATIM. This tool builds the ' +
 				'body (the requests[] array, webSettings, etc.) for you — do NOT ' +
@@ -160,7 +160,7 @@ export function createVersionFromCaptureTool(
 				properties: {
 					providerId: {
 						type: 'string',
-						description: 'UUID of the verification to publish the version on.',
+						description: 'UUID of the provider to publish the version on.',
 					},
 					provider: PROVIDER_SCHEMA,
 					providers: {

package/src/mcp/tools/agent/replay.ts

@@ -1,53 +1,43 @@
-import { replayProvider } from '../../../proof/replay.ts'
-import type { ReclaimProvider } from '../../../provider/schema.ts'
-import { defineTool, type RegisteredTool } from '../../server.ts'
-import type { SecretStore } from './propose.ts'
+/**
+ * `replay_request` — validate a drafted recipe before proving: confirm its
+ * selectors extract the target(s), and (with `withoutSecrets`) that the
+ * endpoint is auth-bound. Authored once as a plain {@link RegisteredTool}; the
+ * backend does the actual replay (MCP re-runs locally, cloud re-issues in the
+ * TEE pod).
+ */
+import { objectSchema, type ResolveBackend } from '../../../authoring/util.ts'
+import { defineTool, type RegisteredTool } from '../../../tools/registry.ts'
 
-export function replayTool(secrets: SecretStore): RegisteredTool {
-	return defineTool<{ provider: unknown, secretParamsRef?: string }>(
+export function replayTool(resolveBackend: ResolveBackend): RegisteredTool {
+	return defineTool<Record<string, unknown>>(
 		{
 			name: 'replay_request',
 			description:
-				'Replay a drafted provider against the live endpoint ' +
-				'using Node fetch (no attestor). ' +
-				'Pre-flight gate before run_proof — ' +
-				'diagnoses CSRF / token-rotation / matcher-too-tight ' +
-				'issues with richer hints than the attestor would produce.',
-			inputSchema: {
-				type: 'object',
-				properties: {
-					provider: { type: 'object', properties: {} },
-					secretParamsRef: { type: 'string' },
+				'Validate the drafted recipe before proving — confirm its selectors '
+				+ 'extract the target value. Returns diagnostics; run before '
+				+ 'proving. Set `withoutSecrets: true` for the AUTH-BOUND check: it '
+				+ 're-issues the request with NO secrets/cookies (an anonymous '
+				+ 'visitor). If the values still extract (valid:true), the endpoint '
+				+ 'is PUBLIC and the proof would not bind to the user — reject it '
+				+ 'and find an auth-bound request instead.',
+			inputSchema: objectSchema(
+				{
+					draftId: { type: 'string' },
+					withoutSecrets: { type: 'boolean' },
 				},
-				required: ['provider'],
-			},
+				['draftId'],
+			),
 		},
-		async({ provider, secretParamsRef }) => {
-			let resolved: Record<string, string> = {}
-			if(secretParamsRef !== undefined) {
-				const r = secrets.resolve(secretParamsRef)
-				if(!r) {
-					throw new Error(
-						`unknown secretParamsRef "${secretParamsRef}" — ` +
-						'the MCP server has restarted or reset_session was called. ' +
-						'Re-run propose_provider to mint a fresh ref.',
-					)
-				}
-
-				resolved = r
-			}
-
-			const result = await replayProvider(provider as ReclaimProvider, resolved)
-			const out: Record<string, unknown> = {
-				status: result.status,
-				matchesOriginal: result.matchesOriginal,
-				bodySnippet: result.body.slice(0, 256),
-			}
-			if(result.hints !== undefined) {
-				out.hints = result.hints
+		async(args) => {
+			const backend = resolveBackend(args)
+			const draft = backend.drafts.get(String(args.draftId))
+			if(!draft) {
+				throw new Error(`no draft ${String(args.draftId)}`)
 			}
 
-			return out
+			return backend.replay(draft, {
+				withoutSecrets: Boolean(args.withoutSecrets),
+			})
 		},
 	)
 }

package/src/mcp/tools/agent/session.ts

@@ -6,7 +6,6 @@ import type { CaptureStore } from './capture.ts'
 export function sessionTools(
 	attachRef: { current?: AttachState, config: ConfigStore },
 	captures: CaptureStore,
-	secrets: { clear: () => void },
 ): RegisteredTool[] {
 	return [
 		defineTool<Record<string, never>>(
@@ -28,17 +27,17 @@ export function sessionTools(
 			{
 				name: 'reset_session',
 				description:
-					'Stop all captures, drop in-memory secrets, and clear capture state.',
+					'Stop all captures and clear capture state — drops every '
+					+ 'session\'s drafts and their in-memory secrets.',
 				inputSchema: { type: 'object', properties: {} },
 			},
 			async() => {
-				for(const s of captures.sessions.values()) {
-					await s.stop().catch(() => {})
+				for(const entry of captures.sessions.values()) {
+					await entry.session.stop().catch(() => {})
 				}
 
 				captures.sessions.clear()
 				delete captures.activeTab
-				secrets.clear()
 				return { reset: true }
 			},
 		),

package/src/mcp/tools/agent/shared.ts

@@ -0,0 +1,152 @@
+/**
+ * Build the shared authoring tools for the MCP, bound to a per-capture LOCAL
+ * backend: a Chrome tab over CDP + the in-process attestor SDK. The tool logic
+ * (navigate/inspect/propose/replay/prove) is authored once in `../../../
+ * authoring` with the shared `defineTool` primitive; this only supplies the
+ * MCP host — resolve the backend from `captureId` (the session handle from
+ * `start_capture`, since one capture bundles the tab, its requests, and its
+ * drafts) and the rich, credential-aware `run_proof` schema.
+ */
+import {
+	type AuthoringBackend,
+	authoringTools,
+	extendTool,
+} from '../../../authoring/index.ts'
+import { runAttestorProof } from '../../../proof/attestor.ts'
+import { replayProvider } from '../../../proof/replay.ts'
+import type { RegisteredTool } from '../../server.ts'
+import type { CaptureEntry, CaptureStore } from './capture.ts'
+import { shapeRichProofResult } from './proof.ts'
+
+/** The local backend for one capture: drive its tab over CDP, read its
+ *  captured requests, prove via the in-process attestor, replay by re-fetch. */
+function localBackend(entry: CaptureEntry): AuthoringBackend {
+	const { tabClient, session, drafts } = entry
+	// The per-tab CDP client is strongly typed to `keyof Commands`; the shared
+	// tools drive it with dynamic method/event names, so view it as string-keyed.
+	const client = tabClient as unknown as {
+		send: (method: string, params: object) => Promise<unknown>
+		once: (e: string, cb: () => void) => void
+		removeListener: (e: string, cb: () => void) => void
+	}
+
+	return {
+		capture: session,
+		drafts,
+		sendCdp: (method, params) => client.send(method, params ?? {}),
+		waitForEvent: (method, timeoutMs) => new Promise((resolve) => {
+			const onEvent = () => {
+				cleanup()
+				resolve('fired')
+			}
+
+			const timer = setTimeout(() => {
+				cleanup()
+				resolve('timeout')
+			}, timeoutMs)
+			const cleanup = () => {
+				clearTimeout(timer)
+				client.removeListener(method, onEvent)
+			}
+
+			client.once(method, onEvent)
+		}),
+		replay: async(draft, opts) => {
+			// Auth-bound check: re-fetch with the secrets dropped. replayProvider
+			// already does a live Node fetch, so empty secrets == anonymous.
+			const secrets = opts?.withoutSecrets ? {} : draft.secrets
+			const result = await replayProvider(draft.provider, secrets)
+			return {
+				status: result.status,
+				matchesOriginal: result.matchesOriginal,
+				bodySnippet: result.body.slice(0, 256),
+				...(result.hints !== undefined ? { hints: result.hints } : {}),
+			}
+		},
+		prove: async(draft, opts) => {
+			const result = await runAttestorProof(
+				draft.provider,
+				draft.secrets,
+				{
+					...(opts?.ownerAddress ? { ownerAddress: opts.ownerAddress } : {}),
+					...(opts?.attestorUrl ? { attestorUrl: opts.attestorUrl } : {}),
+				},
+			)
+			return shapeRichProofResult(result, {
+				provider: draft.provider,
+				hasSecrets: Object.keys(draft.secrets).length > 0,
+				...(opts?.attestorUrl ? { attestorUrl: opts.attestorUrl } : {}),
+			})
+		},
+	}
+}
+
+/** The MCP's rich, credential-aware `run_proof` schema, merged onto the shared
+ *  tool by the host below (the cloud's TEE signs in-enclave, so it needs none
+ *  of this). */
+const RUN_PROOF_EXTRAS = {
+	description:
+		'Run a full zkTLS proof of the drafted recipe through the Reclaim '
+		+ 'attestor SDK. Use only after replay_request looks right — attestor '
+		+ 'calls are expensive. Writes the full claim to '
+		+ '~/.reclaim/claims/<timestamp>.json and returns identifier + '
+		+ 'extractedParameters + claimPath + a prettified `claim` (request '
+		+ 'dropped, byte arrays as base64). With RECLAIM_AGENT_TRACE=1, also '
+		+ 'writes a per-call diagnostic dump (input provider, sentParams, full '
+		+ 'attestor log stream, result) and returns it as `runLogPath`. '
+		+ '`attestorUrl` overrides the default only when the dev supplies a '
+		+ 'specific alternative — do NOT invent backup URLs. `ownerAddress` '
+		+ '(the credential to sign with) is REQUIRED — call resolve_owner_key '
+		+ 'first. errorKind="missing-owner-key" means that address has no known '
+		+ 'private key; re-run resolve_owner_key or issue/import a credential.',
+	properties: {
+		ownerAddress: {
+			type: 'string',
+			pattern: '^0x[0-9a-fA-F]{40}$',
+			description:
+				'ETH address of the credential to sign the claim with. Get it '
+				+ 'from resolve_owner_key first. The private key is resolved '
+				+ 'locally (cache / env / .env) — never passed here.',
+		},
+		attestorUrl: { type: 'string' },
+	},
+	required: ['ownerAddress'],
+}
+
+/** The shared authoring tools mapped to the MCP's shape: resolve each call's
+ *  local backend from `args.captureId`, and widen the input schema — every tool
+ *  takes `captureId`; `run_proof` also gets the credential-aware contract. The
+ *  tools are authored plain in `../../../authoring`; this only wraps them with
+ *  `extendTool` (handlers untouched — loose arg parse keeps `captureId`). */
+export function sharedAuthoringTools(captures: CaptureStore): RegisteredTool[] {
+	const resolveBackend = (args: Record<string, unknown>): AuthoringBackend => {
+		const captureId = String(args.captureId)
+		const entry = captures.sessions.get(captureId)
+		if(!entry) {
+			throw new Error(
+				`no capture ${captureId} — call start_capture first `
+				+ '(it has been reset or never started).',
+			)
+		}
+
+		return localBackend(entry)
+	}
+
+	return authoringTools(resolveBackend).map((tool) => {
+		if(tool.definition.name === 'run_proof') {
+			return extendTool(tool, {
+				description: RUN_PROOF_EXTRAS.description,
+				properties: {
+					captureId: { type: 'string' },
+					...RUN_PROOF_EXTRAS.properties,
+				},
+				required: ['captureId', ...RUN_PROOF_EXTRAS.required],
+			})
+		}
+
+		return extendTool(tool, {
+			properties: { captureId: { type: 'string' } },
+			required: ['captureId'],
+		})
+	})
+}

package/src/old/client.ts

@@ -34,6 +34,15 @@ export interface RegisterProviderBody {
 	useProxy?: boolean
 	providerType?: 'PRIVATE' | 'PUBLIC'
 	requestData: unknown[]
+	/** Page-injection script (old-devtools name for the builder's
+	 *  `webSettings.jsUserScripts`). Top-level on register; nested under
+	 *  `providerConfig` on the config (add-version) body instead. */
+	customInjection?: string
+	/** Accepted at register too (unlike most `providerConfig` extras, which
+	 *  the register controller only reads on config/add-version). */
+	userAgent?: { ios?: string, android?: string }
+	/** Accepted at register too. */
+	pageTitle?: string
 }
 
 export interface UpdateProviderConfigBody {
@@ -42,6 +51,19 @@ export interface UpdateProviderConfigBody {
 	versionInfo: string
 }
 
+/** Body for `POST /api/providers/:providerId` (`updateProviderMetadata`) —
+ *  a genuine PARTIAL update on the PROVIDER document itself (name/
+ *  description/providerType/tags/isActive), distinct from both `register`
+ *  (creates the provider) and `config` (adds an immutable new version). Only
+ *  the fields present get changed; everything else is left untouched. */
+export interface UpdateProviderMetadataBody {
+	name?: string
+	description?: string
+	providerType?: 'PRIVATE' | 'PUBLIC'
+	tags?: string[]
+	isActive?: boolean
+}
+
 export interface MyProvidersQuery {
 	pageKey?: number
 	pageSize?: number
@@ -121,6 +143,40 @@ export class ReclaimOldClient {
 		)
 	}
 
+	/** Full `providerConfig` (loginUrl, customInjection, requestData, ...) for
+	 *  one version — the latest when `version` is omitted. Readable for ANY
+	 *  non-archived provider (not owner-restricted), same as the dashboard's
+	 *  edit-form prefill fetch. */
+	getProviderConfig(
+		providerId: string,
+		version?: string,
+	): Promise<unknown> {
+		return this.#request(
+			'GET',
+			`/providers/${encodeURIComponent(providerId)}/config`,
+			{
+				auth: true,
+				query: version ? { versionNumber: version } : undefined,
+			},
+		)
+	}
+
+	/** Partial update on the PROVIDER document itself — name/description/
+	 *  providerType/tags/isActive, after creation. The backend 403s if you
+	 *  don't own the provider (and aren't admin); other providerConfig-style
+	 *  fields sent here are simply ignored (this endpoint only reads the
+	 *  ones above from the body). */
+	updateProviderMetadata(
+		providerId: string,
+		body: UpdateProviderMetadataBody,
+	): Promise<unknown> {
+		return this.#request(
+			'POST',
+			`/providers/${encodeURIComponent(providerId)}`,
+			{ body, auth: true },
+		)
+	}
+
 	/** Analytics logs for a verification session, from the logs service (a
 	 *  DIFFERENT host than the devtools API — hence its own fetch, not
 	 *  `#request`). Attaches the caller identity when one is set; queried

package/src/old/login-cdp.ts

@@ -18,16 +18,39 @@ import { DEFAULT_LOGIN_URL, oldLoginUrl } from '../consts.ts'
  * `firebaseLocalStorage`) in case a build switches persistence. Returns the
  * token string, or null when the user has not finished logging in yet.
  *
+ * The CDP-launched Chrome reuses a PERSISTENT profile dir across runs, so a
+ * stale `firebase:authUser:*` entry from an earlier (now-expired, ~1h TTL)
+ * session is often still sitting in storage the instant the page loads —
+ * before the developer has clicked anything. Returning that immediately
+ * makes the poll "succeed" on tick one, closing the tab before the developer
+ * can sign in, and the captured token then fails backend verification. So
+ * every candidate's JWT `exp` claim is checked here (in-page, where `atob` is
+ * available) and stale ones are skipped — the loop keeps polling until a
+ * genuinely fresh token shows up from an interactive sign-in.
+ *
  * Evaluated in-page with `awaitPromise` so the async IndexedDB branch resolves.
  */
-const EXTRACT_TOKEN_JS = `(async () => {
+export const EXTRACT_TOKEN_JS = `(async () => {
+	const isFresh = (token) => {
+		try {
+			const payload = JSON.parse(
+				atob(token.split('.')[1].replace(/-/g, '+').replace(/_/g, '/'))
+			)
+			// No exp claim to check — don't block a token we can't evaluate.
+			if (typeof payload.exp !== 'number') return true
+			// 60s buffer so a token that's about to expire isn't treated as fresh.
+			return payload.exp * 1000 > Date.now() + 60000
+		} catch (e) {
+			return true
+		}
+	}
 	try {
 		for (let i = 0; i < localStorage.length; i++) {
 			const k = localStorage.key(i)
 			if (k && k.indexOf('firebase:authUser:') === 0) {
 				const v = JSON.parse(localStorage.getItem(k) || 'null')
 				const t = v && v.stsTokenManager && v.stsTokenManager.accessToken
-				if (t) return t
+				if (t && isFresh(t)) return t
 			}
 		}
 	} catch (e) {}
@@ -49,7 +72,9 @@ const EXTRACT_TOKEN_JS = `(async () => {
 					all.onsuccess = () => {
 						for (const row of (all.result || [])) {
 							const m = row && row.value && row.value.stsTokenManager
-							if (m && m.accessToken) { resolve(m.accessToken); return }
+							if (m && m.accessToken && isFresh(m.accessToken)) {
+								resolve(m.accessToken); return
+							}
 						}
 						resolve(null)
 					}