@namzu/sdk 48.3.1 → 50.0.0

package/src/plugin/lifecycle.ts

@@ -49,6 +49,7 @@ interface PluginContributionRecord {
 	mcpToolsets: Toolset[]
 	mcpUnsubscribers: Array<() => void>
 	mcpNamesBySource: Map<string, Set<string>>
+	configReleases: Array<() => void>
 	/** Namespaced skill names, so rollback and disable can take them back. */
 	skillNames: string[]
 }
@@ -62,6 +63,68 @@ interface PluginAdmission {
 	readonly inCode?: DefinedPlugin
 }
 
+const DEFAULT_PLUGIN_MCP_CONNECT_TIMEOUT_MS = 10_000
+const PLUGIN_MCP_CLOSE_TIMEOUT_MS = 5_000
+
+/** One deadline across handshake and all initial discovery requests. */
+async function beforePluginMcpDeadline<T>(
+	work: () => Promise<T>,
+	deadlineAt: number,
+	timeoutMs: number,
+	serverName: string,
+	onLate?: (value: T) => void,
+	onTimeout?: () => void,
+): Promise<T> {
+	const expired = (): Error =>
+		new Error(`Plugin MCP server "${serverName}" did not answer within ${timeoutMs}ms`)
+	const remaining = deadlineAt - Date.now()
+	if (remaining <= 0) throw expired()
+	let timer: ReturnType<typeof setTimeout> | undefined
+	let timedOut = false
+	try {
+		const pending = work()
+		// A timed-out discovery can still finish after rollback. In particular,
+		// mcpToolset() starts a reconnect supervisor just before it returns.
+		// Close that late result without publishing any of its tools.
+		void pending.then(
+			(value) => {
+				if (timedOut) onLate?.(value)
+			},
+			() => {},
+		)
+		return await Promise.race([
+			pending,
+			new Promise<never>((_, reject) => {
+				timer = setTimeout(() => {
+					timedOut = true
+					onTimeout?.()
+					reject(expired())
+				}, remaining)
+			}),
+		])
+	} finally {
+		if (timer) clearTimeout(timer)
+	}
+}
+
+/** Teardown is best-effort, but one stalled close must not block rollback or disable. */
+async function closePluginMcpWithin(work: () => Promise<void>, label: string): Promise<void> {
+	let timer: ReturnType<typeof setTimeout> | undefined
+	try {
+		await Promise.race([
+			work(),
+			new Promise<never>((_, reject) => {
+				timer = setTimeout(
+					() => reject(new Error(`${label} did not close within ${PLUGIN_MCP_CLOSE_TIMEOUT_MS}ms`)),
+					PLUGIN_MCP_CLOSE_TIMEOUT_MS,
+				)
+			}),
+		])
+	} finally {
+		if (timer) clearTimeout(timer)
+	}
+}
+
 /** Dynamic imports bypass ToolDefinition's TypeScript contract. */
 function assertPluginTool(
 	value: unknown,
@@ -100,6 +163,9 @@ function immutableManifest(manifest: PluginDefinition['manifest']): PluginDefini
 			command: server.command,
 			...(server.args ? { args: Object.freeze([...server.args]) } : {}),
 			...(server.env ? { env: Object.freeze({ ...server.env }) } : {}),
+			...(server.connectTimeoutMs !== undefined
+				? { connectTimeoutMs: server.connectTimeoutMs }
+				: {}),
 		}),
 	)
 	return Object.freeze({
@@ -199,6 +265,8 @@ export class PluginLifecycleManager {
 		}>
 	> = new Map()
 	private pluginContributions: Map<PluginId, PluginContributionRecord> = new Map()
+	/** Reserve each id before async admission so lifecycle calls cannot overlap. */
+	private readonly lifecycleTails = new Map<PluginId, Promise<void>>()
 	/** Immutable executable admissions owned by this manager, never by the mutable registry. */
 	private pluginAdmissions: Map<PluginId, PluginAdmission> = new Map()
 	private hookTimeoutMs: number
@@ -206,18 +274,16 @@ export class PluginLifecycleManager {
 	private readonly scopeRoots: Readonly<Record<PluginScope, string>>
 	private log: Logger
 	/**
-	 * The admission boundary for everything a plugin's MCP servers advertise.
+	 * The cross-enable drift history for each plugin-owned MCP source.
 	 *
-	 * One instance for the whole manager rather than one per plugin, and that
-	 * is the part that matters: the instance is what remembers each server's
-	 * previously admitted tool set, so a server that changes between one
-	 * plugin being disabled and the next being enabled is still noticed. A
-	 * per-plugin instance would forget on every teardown, which is precisely
-	 * the window a rug pull uses.
+	 * The toolset applies policy and performs the only listing. It passes the
+	 * admitted snapshot here after it commits, keyed by its full plugin source.
+	 * Keeping this recorder for the manager lifetime detects a server that
+	 * changes between disable and the next enable without conflating unrelated
+	 * plugins that use the same local server label.
 	 *
-	 * Its client list is deliberately left empty — `discoverFrom` takes the
-	 * client directly, so registering it here would be bookkeeping nothing
-	 * reads.
+	 * Its client list stays empty because this instance records snapshots;
+	 * it never makes a second request to the server.
 	 */
 	private mcpDiscovery: MCPToolDiscovery
 	private readonly mcpToolPolicies?: Readonly<Record<string, MCPToolPolicy>>
@@ -235,8 +301,20 @@ export class PluginLifecycleManager {
 		this.onMCPToolDrift = config.onMCPToolDrift
 		this.log = config.log.child({ [SCOPE_ATTRIBUTE]: 'plugin/lifecycle' })
 		this.mcpDiscovery = new MCPToolDiscovery([], {
-			...(config.mcpToolPolicies ? { policies: config.mcpToolPolicies } : {}),
-			...(config.onMCPToolDrift ? { onDrift: config.onMCPToolDrift } : {}),
+			...(config.onMCPToolDrift
+				? {
+						onDrift: (event) => {
+							try {
+								this.onMCPToolDrift?.(event)
+							} catch (error) {
+								this.log.warn('Plugin MCP drift listener failed', {
+									'namzu.plugin.mcp_server': event.serverName,
+									'exception.message': toErrorMessage(error),
+								})
+							}
+						},
+					}
+				: {}),
 			logger: this.log,
 		})
 	}
@@ -453,6 +531,21 @@ export class PluginLifecycleManager {
 		})
 	}
 
+	private serializeLifecycle<T>(pluginId: PluginId, work: () => Promise<T>): Promise<T> {
+		const previous = this.lifecycleTails.get(pluginId) ?? Promise.resolve()
+		const running = previous.then(work)
+		// A failed enable must not poison later disable, retry or uninstall.
+		const tail = running.then(
+			() => undefined,
+			() => undefined,
+		)
+		this.lifecycleTails.set(pluginId, tail)
+		void tail.then(() => {
+			if (this.lifecycleTails.get(pluginId) === tail) this.lifecycleTails.delete(pluginId)
+		})
+		return running
+	}
+
 	private async readLegacyAdmission(plugin: PluginDefinition): Promise<PluginAdmission> {
 		const rootDir = await resolveWithinReal(this.scopeRoots[plugin.scope], plugin.rootDir)
 		const manifest = immutableManifest(
@@ -482,7 +575,11 @@ export class PluginLifecycleManager {
 		})
 	}
 
-	async enable(pluginId: PluginId): Promise<void> {
+	enable(pluginId: PluginId): Promise<void> {
+		return this.serializeLifecycle(pluginId, () => this.enableOwned(pluginId))
+	}
+
+	private async enableOwned(pluginId: PluginId): Promise<void> {
 		const plugin = this.pluginRegistry.getOrThrow(pluginId)
 		let admission = this.pluginAdmissions.get(pluginId)
 
@@ -543,6 +640,7 @@ export class PluginLifecycleManager {
 			mcpToolsets: [],
 			mcpUnsubscribers: [],
 			mcpNamesBySource: new Map(),
+			configReleases: [],
 			skillNames: [],
 		}
 
@@ -703,30 +801,75 @@ export class PluginLifecycleManager {
 			},
 			logger: this.log,
 		})
-
-		await client.connect()
+		// A failed handshake still owns a transport (and possibly a child
+		// process). Put it under rollback ownership before the first await.
 		contributions.mcpClients.push(client)
+		const timeoutMs = config.connectTimeoutMs ?? DEFAULT_PLUGIN_MCP_CONNECT_TIMEOUT_MS
+		const deadlineAt = Date.now() + timeoutMs
+		const closeLateClient = () => {
+			void closePluginMcpWithin(
+				() => client.disconnect(),
+				`Plugin MCP server "${config.name}" after late connection`,
+			).catch((error) => {
+				this.log.warn('Late MCP disconnect failed', {
+					'namzu.mcp.client_id': client.id,
+					'exception.message': toErrorMessage(error),
+				})
+			})
+		}
+		await beforePluginMcpDeadline(
+			() => client.connect(),
+			deadlineAt,
+			timeoutMs,
+			config.name,
+			closeLateClient,
+		)
 
 		// The toolset owns reconnection and reads this policy on each attempt.
 		const policyScope = this.configRegistry?.register(
-			`mcp.${config.name}`,
+			`mcp.plugin.${pluginName}.${config.name}`,
 			MCPReconnectOptionsSchema,
 		)
-		// Preserve cross-disable drift detection. The live toolset below owns
-		// changes during this enablement; this manager-owned discovery remembers
-		// the server's earlier admission across clients and plugin lifetimes.
-		await this.mcpDiscovery.discoverFrom(client)
+		if (policyScope) contributions.configReleases.push(() => policyScope.dispose())
+		// The toolset performs the only listing. Record precisely the admitted
+		// snapshot it mounts, including later refreshes, under the plugin source.
 		const sourceId = `plugin:${pluginName}/mcp:${config.name}`
 		const policy = this.mcpToolPolicies?.[config.name] ?? this.mcpToolPolicies?.['*']
-		const entries = await mcpToolset(client, {
-			id: sourceId,
-			availability: 'deferred',
-			allow: policy?.allow,
-			deny: policy?.deny,
-			reconnect: policyScope ? () => policyScope.get() : {},
-			onDrift: this.onMCPToolDrift,
-			logger: this.log,
-		})
+		let acceptingSnapshot = true
+		const entries = await beforePluginMcpDeadline(
+			() =>
+				mcpToolset(client, {
+					id: sourceId,
+					availability: 'deferred',
+					allow: policy?.allow,
+					deny: policy?.deny,
+					reconnect: policyScope ? () => policyScope.get() : {},
+					onToolsAdmitted: (tools) => {
+						if (acceptingSnapshot) {
+							this.mcpDiscovery.recordAdmittedTools(sourceId, client.id, config.name, tools)
+						}
+					},
+					logger: this.log,
+				}),
+			deadlineAt,
+			timeoutMs,
+			config.name,
+			(lateEntries) => {
+				for (const entry of lateEntries) {
+					void closePluginMcpWithin(async () => {
+						await entry.close?.()
+					}, `Late MCP toolset ${entry.source.id}`).catch((error) => {
+						this.log.warn('Late MCP toolset close failed', {
+							'namzu.toolset.source_id': entry.source.id,
+							'exception.message': toErrorMessage(error),
+						})
+					})
+				}
+			},
+			() => {
+				acceptingSnapshot = false
+			},
+		)
 		contributions.mcpToolsets.push(...entries)
 		const wrapped = entries.map((entry) =>
 			prefixed(entry, `${pluginName}${PLUGIN_NAMESPACE_SEPARATOR}`),
@@ -779,25 +922,49 @@ export class PluginLifecycleManager {
 		contributions: PluginContributionRecord,
 		operation: 'rollback' | 'disable',
 	): Promise<void> {
-		for (const unsubscribe of contributions.mcpUnsubscribers) unsubscribe()
-		for (const entry of contributions.mcpToolsets) await entry.close?.()
-		for (const client of contributions.mcpClients) {
-			try {
-				await client.disconnect()
-			} catch (error) {
-				this.log.warn('MCP disconnect failed', {
-					'namzu.plugin.operation': operation,
-					'namzu.mcp.client_id': client.id,
-					'exception.message': toErrorMessage(error),
-				})
+		try {
+			for (const unsubscribe of contributions.mcpUnsubscribers) unsubscribe()
+			await Promise.all(
+				contributions.mcpToolsets.map(async (entry) => {
+					try {
+						await closePluginMcpWithin(async () => {
+							await entry.close?.()
+						}, `MCP toolset ${entry.source.id}`)
+					} catch (error) {
+						this.log.warn('MCP toolset close failed', {
+							'namzu.plugin.operation': operation,
+							'namzu.toolset.source_id': entry.source.id,
+							'exception.message': toErrorMessage(error),
+						})
+					}
+				}),
+			)
+			await Promise.all(
+				contributions.mcpClients.map(async (client) => {
+					try {
+						await closePluginMcpWithin(() => client.disconnect(), `MCP client ${client.id}`)
+					} catch (error) {
+						this.log.warn('MCP disconnect failed', {
+							'namzu.plugin.operation': operation,
+							'namzu.mcp.client_id': client.id,
+							'exception.message': toErrorMessage(error),
+						})
+					}
+				}),
+			)
+			for (const names of contributions.mcpNamesBySource.values()) {
+				for (const name of names) this.removeContributedTool(name)
 			}
+		} finally {
+			for (const release of contributions.configReleases) release()
 		}
-		for (const names of contributions.mcpNamesBySource.values()) {
-			for (const name of names) this.removeContributedTool(name)
-		}
 	}
 
-	async disable(pluginId: PluginId): Promise<void> {
+	disable(pluginId: PluginId): Promise<void> {
+		return this.serializeLifecycle(pluginId, () => this.disableOwned(pluginId))
+	}
+
+	private async disableOwned(pluginId: PluginId): Promise<void> {
 		const plugin = this.pluginRegistry.getOrThrow(pluginId)
 		const admission = this.pluginAdmissions.get(pluginId)
 		const contributions = this.pluginContributions.get(pluginId)
@@ -856,12 +1023,16 @@ export class PluginLifecycleManager {
 		})
 	}
 
-	async uninstall(pluginId: PluginId): Promise<void> {
+	uninstall(pluginId: PluginId): Promise<void> {
+		return this.serializeLifecycle(pluginId, () => this.uninstallOwned(pluginId))
+	}
+
+	private async uninstallOwned(pluginId: PluginId): Promise<void> {
 		const plugin = this.pluginRegistry.getOrThrow(pluginId)
 		const admission = this.pluginAdmissions.get(pluginId)
 
 		if (this.pluginContributions.has(pluginId)) {
-			await this.disable(pluginId)
+			await this.disableOwned(pluginId)
 		}
 
 		this.pluginRegistry.unregister(pluginId)

package/src/plugin/shell-hook.ts

@@ -58,8 +58,9 @@
  * and does not block: one that could not answer in time has not answered no.
  */
 
-import { spawn } from 'node:child_process'
+import type { spawn } from 'node:child_process'
 
+import { spawnHostShell } from '../tools/command-shell.js'
 import type { PluginId } from '../types/ids/index.js'
 import type {
 	PluginCompactionInfo,
@@ -211,7 +212,7 @@ export function runShellHook(
 	return new Promise((resolve) => {
 		let child: ReturnType<typeof spawn>
 		try {
-			child = spawn('sh', ['-c', entry.command], {
+			child = spawnHostShell(entry.command, {
 				cwd: input.cwd,
 				env: {
 					...inherited,
@@ -229,6 +230,11 @@ export function runShellHook(
 				// the stdout pipe, and the outcome cannot settle until it exits on
 				// its own — the hook's deadline becomes the grandchild's.
 				detached: process.platform !== 'win32',
+				// A hook has always run under `sh`, whatever shell the `bash` tool
+				// chose. Windows has no `sh`, so there the host's own shell runs it.
+				...(process.platform === 'win32'
+					? {}
+					: { shell: { path: 'sh', dialect: 'sh', source: 'sh' } as const }),
 			})
 		} catch (error) {
 			resolve({

package/src/process/kill-tree.ts

@@ -1,6 +1,12 @@
 import { execFileSync } from 'node:child_process'
 import type { spawn } from 'node:child_process'
 
+/** The system's own taskkill, so a PATH entry cannot stand in for it. */
+function taskkillPath(): string {
+	const root = process.env.SystemRoot ?? process.env.windir
+	return root ? `${root}\\System32\\taskkill.exe` : 'taskkill'
+}
+
 /**
  * Signal a spawned child AND everything it forked.
  *
@@ -40,7 +46,10 @@ export function killTree(child: ReturnType<typeof spawn>, signal: NodeJS.Signals
 	if (!child.pid) return
 	try {
 		if (process.platform === 'win32') {
-			execFileSync('taskkill', ['/pid', String(child.pid), '/t', '/f'], { stdio: 'ignore' })
+			execFileSync(taskkillPath(), ['/pid', String(child.pid), '/t', '/f'], {
+				stdio: 'ignore',
+				windowsHide: true,
+			})
 		} else {
 			process.kill(-child.pid, signal)
 		}

package/src/prompt/resident-learning.ts

@@ -103,7 +103,7 @@ export function createResidentStepContext(
 			...contributions,
 			Object.freeze({
 				id: 'namzu.resident-step.learning-catalogue',
-				placement: 'dynamic' as const,
+				placement: 'context' as const,
 				render: () =>
 					[
 						'## Available evaluated resident skills',
@@ -113,7 +113,7 @@ export function createResidentStepContext(
 			}),
 			Object.freeze({
 				id: 'namzu.resident-step.selected-learning',
-				placement: 'turn' as const,
+				placement: 'context' as const,
 				render: () => {
 					if (!selected.size) return null
 					try {

package/src/prompt/resident-step.ts

@@ -58,8 +58,8 @@ export interface ResidentStepPromptOptions {
  * contributions. Register them on the registry supplied to `query`.
  *
  * The static contribution carries stable work guidance and the host's output
- * contract. The dynamic contribution captures this invocation's state and
- * approved learning, outside the cached prefix. Both remain present on every
+ * contract. The context contribution captures this invocation's state and
+ * approved learning as request-only user-role context. Both remain present on every
  * iteration; build fresh contributions for the next admitted step.
  *
  * Project instructions and authorization remain on their existing host/runtime
@@ -128,14 +128,14 @@ export function createResidentStepContributions(
 		}),
 		Object.freeze({
 			id: 'namzu.resident-step.continuation',
-			placement: 'dynamic' as const,
+			placement: 'context' as const,
 			render: () => snapshot,
 		}),
 		...(boundNames.length
 			? [
 					Object.freeze({
 						id: 'namzu.resident-step.source-bound-learning',
-						placement: 'turn' as const,
+						placement: 'context' as const,
 						render: () => {
 							let sources: readonly ResidentLearningSource[] = []
 							try {

package/src/provider/errors.ts

@@ -386,6 +386,71 @@ function vendorRetryAfter(err: unknown): string | undefined {
 	return undefined
 }
 
+/** Response headers that name the request, as the vendors that send one spell it. */
+const REQUEST_ID_HEADERS = ['x-request-id', 'request-id', 'x-goog-request-id'] as const
+
+/** A header off an SDK error's captured response headers (a `Headers` or a plain object). */
+function vendorHeader(err: unknown, names: readonly string[]): string | undefined {
+	if (typeof err !== 'object' || err === null) return undefined
+	const headers =
+		(err as { headers?: unknown }).headers ??
+		(err as { $response?: { headers?: unknown } }).$response?.headers
+	if (!headers) return undefined
+	for (const name of names) {
+		if (typeof (headers as Headers).get === 'function') {
+			const value = (headers as Headers).get(name)
+			if (value) return value
+			continue
+		}
+		const value = (headers as Record<string, unknown>)[name]
+		if (typeof value === 'string' && value) return value
+	}
+	return undefined
+}
+
+const FIELD_VALUE = /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/
+
+function fieldValue(value: unknown): string | undefined {
+	return typeof value === 'string' && FIELD_VALUE.test(value) && redactSecrets(value) === value
+		? value
+		: undefined
+}
+
+/**
+ * The provider's structured fields beside its sentence, in the one body shape every host already
+ * reads (`{"error":{"message","type","code","param"},"request_id"}`).
+ *
+ * A vendor SDK whose error message is only the parsed sentence (OpenAI's "403 <message>") still
+ * holds the body's `type`, `code`, `param` and the response's request ID as fields; a host that
+ * receives the message alone cannot show them, while Anthropic's message carries its whole body
+ * and so shows them. The fields are bounded identifiers (never a body), so nothing echoed can ride
+ * along. With nothing but a sentence the result is that sentence unchanged.
+ */
+export function structuredVendorDetail(input: {
+	readonly message: string | undefined
+	readonly type?: unknown
+	readonly code?: unknown
+	readonly param?: unknown
+	readonly requestId?: unknown
+}): string | undefined {
+	const message = vendorDetail(input.message?.replace(/^\d{3}\s+/, ''))
+	const type = fieldValue(input.type)
+	const code = fieldValue(input.code)
+	const param = fieldValue(input.param)
+	const requestId = fieldValue(input.requestId)
+	if (!type && !code && !param && !requestId) return message
+	if (!message) return undefined
+	return JSON.stringify({
+		error: {
+			message,
+			...(type ? { type } : {}),
+			...(code ? { code } : {}),
+			...(param ? { param } : {}),
+		},
+		...(requestId ? { request_id: requestId } : {}),
+	})
+}
+
 /**
  * Classify an error thrown by a vendor SDK and replace it.
  *
@@ -460,7 +525,18 @@ export function providerVendorError(input: {
 		input.retryAfter ?? vendorRetryAfter(error),
 		input.now ?? Date.now(),
 	)
-	const detail = vendorDetail(message)
+	const fields = error as { type?: unknown; param?: unknown; requestID?: unknown } | null
+	// A message that already carries its body (Anthropic's) has the fields; one that is only the
+	// parsed sentence (OpenAI's) gets them from the SDK error's own properties.
+	const detail = carriesBody(message)
+		? vendorDetail(message)
+		: structuredVendorDetail({
+				message,
+				type: fields?.type,
+				code: exactProviderCode,
+				param: fields?.param,
+				requestId: fields?.requestID ?? vendorHeader(error, REQUEST_ID_HEADERS),
+			})
 	return new ProviderRequestError({
 		kind,
 		providerId: input.providerId,
@@ -471,6 +547,51 @@ export function providerVendorError(input: {
 	})
 }
 
+/** Anthropic's SDK words a failure "<status> <JSON body>"; OpenAI's is "<status> <sentence>", which may itself hold a brace. */
+function carriesBody(message: string): boolean {
+	const rest = message.replace(/^\d{3}\s+/, '').trim()
+	if (!rest.startsWith('{')) return false
+	try {
+		const parsed: unknown = JSON.parse(rest)
+		return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed)
+	} catch {
+		return false
+	}
+}
+
+function parsedBody(body: unknown): Record<string, unknown> | undefined {
+	let decoded = body
+	if (typeof decoded === 'string') {
+		try {
+			decoded = JSON.parse(decoded)
+		} catch {
+			return undefined
+		}
+	}
+	return typeof decoded === 'object' && decoded !== null && !Array.isArray(decoded)
+		? (decoded as Record<string, unknown>)
+		: undefined
+}
+
+/** `type`/`status`, `code` and `param` of a `{ error: {...} }` body, only where it spells them. */
+function bodyErrorFields(body: Record<string, unknown> | undefined): {
+	type?: unknown
+	code?: unknown
+	param?: unknown
+} {
+	const inner =
+		body && typeof body.error === 'object' && body.error !== null
+			? (body.error as Record<string, unknown>)
+			: undefined
+	if (!inner) return {}
+	// Google names its type `status` ("PERMISSION_DENIED") and sends a numeric `code` that is the HTTP status.
+	return {
+		type: inner.type ?? (typeof inner.status === 'string' ? inner.status : undefined),
+		code: typeof inner.code === 'string' ? inner.code : undefined,
+		param: inner.param,
+	}
+}
+
 /**
  * Build a classified error from a failed HTTP response.
  *
@@ -482,11 +603,23 @@ export function providerHttpError(input: {
 	readonly status: number
 	readonly body?: string | null
 	readonly retryAfter?: string | null
+	/** The response's request ID header, when the driver read one. */
+	readonly requestId?: string | null
 	readonly now?: number
 }): ProviderRequestError {
 	const kind = classifyProviderHttpStatus(input.status, input.body)
 	const retryAfterMs = parseRetryAfterMs(input.retryAfter, input.now ?? Date.now())
-	const detail = vendorDetail(input.body)
+	const body = parsedBody(input.body)
+	const bodyError = bodyErrorFields(body)
+	const detail = body
+		? structuredVendorDetail({
+				message: vendorDetail(input.body),
+				type: bodyError.type,
+				code: bodyError.code,
+				param: bodyError.param,
+				requestId: input.requestId,
+			})
+		: vendorDetail(input.body)
 	const exactProviderCode = providerCode(input.body)
 	return new ProviderRequestError({
 		kind,