@namzu/sdk 40.0.0 → 42.0.0

package/src/connector/mcp/errors.ts

@@ -0,0 +1,171 @@
+import { RESOURCE_NOT_FOUND_CODES } from '../../constants/mcp/index.js'
+import type { MCPInputRequest, MCPJsonRpcError } from '../../types/connector/index.js'
+
+/**
+ * The 2026-07-28 error codes a modern MCP server answers with. Kept private
+ * to this module: callers narrow on the predicates below rather than
+ * comparing magic numbers, so era negotiation, header recovery and the
+ * capability path never need to know the numbers themselves.
+ */
+const UNSUPPORTED_PROTOCOL_VERSION_CODE = -32022
+const MISSING_REQUIRED_CLIENT_CAPABILITY_CODE = -32021
+const HEADER_MISMATCH_CODE = -32020
+
+/**
+ * A JSON-RPC error reply from an MCP peer, with its `code` and `data`
+ * preserved.
+ *
+ * `MCPClient.handleMessage` used to flatten every error reply into
+ * `new Error('MCP error {code}: {message}')`, which threw away the one
+ * thing a caller needs to react to it programmatically. Era negotiation
+ * reads `code === -32022` and `data.supported`; header recovery reads
+ * `-32020`; the capability path reads `-32021` and `data.requiredCapabilities`.
+ * None of that is recoverable from a formatted string.
+ *
+ * A subclass of `Error`, never a replacement: every existing catch site that
+ * treats the rejection as a plain `Error` keeps working unchanged, and
+ * `.message` keeps its original `MCP error {code}: {message}` text so no
+ * existing log line or string-matching test is disturbed.
+ */
+export class MCPProtocolError extends Error {
+	readonly code: number
+	readonly data?: unknown
+
+	constructor(code: number, message: string, data?: unknown) {
+		super(`MCP error ${code}: ${message}`)
+		this.name = 'MCPProtocolError'
+		this.code = code
+		this.data = data
+	}
+}
+
+/**
+ * A JSON-RPC error reply whose `code` was missing or not an integer.
+ *
+ * A well-formed peer never sends this; a malformed one must not be mistaken
+ * for a recognized protocol error, because era negotiation and the recovery
+ * paths key their fallback behaviour on exactly which modern error code (or
+ * none) came back. Named distinctly from `MCPProtocolError` so that no
+ * `is*Error` predicate below can ever match it.
+ */
+export class MCPMalformedErrorReplyError extends Error {
+	constructor(receivedCode: unknown, message: unknown) {
+		super(`MCP error reply had a malformed code (${JSON.stringify(receivedCode)}): ${message}`)
+		this.name = 'MCPMalformedErrorReplyError'
+	}
+}
+
+/**
+ * An HTTP response that was not a success, with the body it carried.
+ *
+ * The body is the reason this type exists. A status alone cannot tell a
+ * legacy origin apart from a modern one: a modern server answers an unknown
+ * method with `404` and a JSON-RPC `-32601` body specifically so a client
+ * can distinguish it from the `404` of a server that has never heard of the
+ * modern protocol. Discarding the body — which this transport used to do —
+ * makes that distinction unreachable and turns every `404` into a fallback.
+ *
+ * `.message` is unchanged from the plain `Error` this replaces, so existing
+ * logs and assertions that match on the text are undisturbed.
+ */
+export class MCPHttpStatusError extends Error {
+	readonly status: number
+	readonly statusText: string
+	readonly bodyText: string
+
+	constructor(where: string, status: number, statusText: string, bodyText: string) {
+		super(`${where}: HTTP ${status}: ${statusText}`)
+		this.name = 'MCPHttpStatusError'
+		this.status = status
+		this.statusText = statusText
+		this.bodyText = bodyText
+	}
+}
+
+/**
+ * Build the rejection reason for a JSON-RPC error reply.
+ *
+ * The wire message is cast to `MCPJsonRpcMessage` at the transport boundary
+ * without validation (see `JSON.parse(...) as MCPJsonRpcMessage` in
+ * `stdio.ts`, `http-sse.ts`, `streamable-http.ts`), so `error.code` is only
+ * a `number` by declared type — a misbehaving peer can still send anything.
+ * Guarding here, once, keeps that distrust out of `handleMessage`.
+ */
+export function protocolErrorFromReply(error: MCPJsonRpcError): Error {
+	const code: unknown = error.code
+	if (typeof code !== 'number' || !Number.isInteger(code)) {
+		return new MCPMalformedErrorReplyError(code, error.message)
+	}
+	return new MCPProtocolError(code, error.message, error.data)
+}
+
+/** A modern server answered that it does not speak the requested protocol version. */
+export function isUnsupportedProtocolVersionError(error: unknown): error is MCPProtocolError {
+	return error instanceof MCPProtocolError && error.code === UNSUPPORTED_PROTOCOL_VERSION_CODE
+}
+
+/** A modern server answered that this client lacks a capability the request required. */
+export function isMissingRequiredClientCapabilityError(error: unknown): error is MCPProtocolError {
+	return error instanceof MCPProtocolError && error.code === MISSING_REQUIRED_CLIENT_CAPABILITY_CODE
+}
+
+/** A modern server rejected a request's `Mcp-Param-*` headers as stale against its current schema. */
+export function isHeaderMismatchError(error: unknown): error is MCPProtocolError {
+	return error instanceof MCPProtocolError && error.code === HEADER_MISMATCH_CODE
+}
+
+/**
+ * A server answered that the resource, prompt or tool a request named does
+ * not exist — the current spec's `-32002`, or the older `-32602` a
+ * pre-2025-06-18 server may still use for the same condition (see
+ * {@link RESOURCE_NOT_FOUND_CODES}).
+ */
+export function isResourceNotFoundError(error: unknown): error is MCPProtocolError {
+	return error instanceof MCPProtocolError && RESOURCE_NOT_FOUND_CODES.includes(error.code)
+}
+
+/**
+ * A result named a `resultType` this client does not recognize.
+ *
+ * The spec's own words: "A resultType of any value unrecognized by the
+ * client MUST be considered invalid." Accepting it silently would mean
+ * reading fields from a shape a future revision defines as if they meant
+ * what they mean today, or finding none and returning an empty result with
+ * no diagnostic. Refusing it is the only reading that MUST leaves open.
+ */
+export class MCPInvalidResultTypeError extends Error {
+	readonly resultType: unknown
+
+	constructor(resultType: unknown) {
+		super(`MCP result carried an unrecognized resultType: ${JSON.stringify(resultType)}`)
+		this.name = 'MCPInvalidResultTypeError'
+		this.resultType = resultType
+	}
+}
+
+/**
+ * A tool call asked this client for input it has no way to supply.
+ *
+ * namzu declares `clientCapabilities: {}`, so MRTR rule 7 means a
+ * CONFORMING server never sends an `inputRequests` this client did not
+ * declare support for. This is the defensive path: a non-conforming
+ * server's demand, or a second `input_required` after the one automatic
+ * retry the spec allows for the `requestState`-only case. Carries the raw
+ * `inputRequests` so a caller — `mcpToolToToolDefinition`'s `execute`, or a
+ * host calling `MCPClient.callTool` directly — can name what was asked for
+ * without this class knowing what a `ToolResult` is.
+ */
+export class MCPInputRequiredError extends Error {
+	readonly inputRequests: readonly MCPInputRequest[]
+
+	constructor(inputRequests: readonly MCPInputRequest[]) {
+		const methods = inputRequests.map((request) => request.method)
+		super(
+			methods.length > 0
+				? `MCP tool call requires input this client cannot supply: ${methods.join(', ')}`
+				: 'MCP tool call requires input this client cannot supply',
+		)
+		this.name = 'MCPInputRequiredError'
+		this.inputRequests = inputRequests
+	}
+}

package/src/connector/mcp/http-sse.ts

@@ -1,4 +1,5 @@
 import type {
+	MCPFetchLike,
 	MCPHttpSseTransportConfig,
 	MCPJsonRpcMessage,
 	MCPTransport,
@@ -38,6 +39,8 @@ export class HttpSseTransport implements MCPTransport {
 	private postUrl: string
 	private log: Logger
 	private readonly timeoutMs: number
+	/** Defaults to the ambient global `fetch`; never read again once captured. */
+	private readonly fetchImpl: MCPFetchLike
 
 	constructor(
 		private readonly config: MCPHttpSseTransportConfig,
@@ -50,6 +53,7 @@ export class HttpSseTransport implements MCPTransport {
 			config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
 			'HttpSseTransport timeoutMs',
 		)
+		this.fetchImpl = config.fetch ?? fetch
 		this.log = resolveLogger(log).child({ [SCOPE_ATTRIBUTE]: 'connector/mcp/http-sse' })
 	}
 
@@ -105,12 +109,9 @@ export class HttpSseTransport implements MCPTransport {
 
 		try {
 			const response = await operation.run(() =>
-				fetch(this.postUrl, {
+				this.fetchImpl(this.postUrl, {
 					method: 'POST',
-					headers: {
-						'Content-Type': 'application/json',
-						...this.config.headers,
-					},
+					headers: this.buildHeaders(options?.headers),
 					body: JSON.stringify(message),
 					redirect: 'manual',
 					signal: operation.signal,
@@ -153,6 +154,22 @@ export class HttpSseTransport implements MCPTransport {
 		return this.connected
 	}
 
+	/**
+	 * `extra` comes from `MCPTransportSendOptions.headers` — the client's
+	 * per-send authority — and is merged over this transport's own static
+	 * config headers so a caller's value wins on a collision. See
+	 * {@link StreamableHttpTransport}'s method of the same name, which this
+	 * mirrors; the HTTP-SSE POST had no equivalent merge until now, so a
+	 * per-request header or bearer token silently never reached the wire.
+	 */
+	private buildHeaders(extra?: Readonly<Record<string, string>>): Record<string, string> {
+		return {
+			'Content-Type': 'application/json',
+			...this.config.headers,
+			...extra,
+		}
+	}
+
 	private beginSend(signal: AbortSignal | undefined): {
 		readonly controller: AbortController
 		readonly generation: number
@@ -200,7 +217,7 @@ export class HttpSseTransport implements MCPTransport {
 	}
 
 	private async listenSSE(generation: number, signal: AbortSignal): Promise<void> {
-		const response = await fetch(this.sseUrl, {
+		const response = await this.fetchImpl(this.sseUrl, {
 			headers: {
 				Accept: 'text/event-stream',
 				...this.config.headers,

package/src/connector/mcp/index.ts

@@ -4,6 +4,43 @@ export { StreamableHttpTransport } from './streamable-http.js'
 
 export { MCPClient } from './client.js'
 
+export {
+	isHeaderMismatchError,
+	isMissingRequiredClientCapabilityError,
+	isResourceNotFoundError,
+	isUnsupportedProtocolVersionError,
+	MCPHttpStatusError,
+	MCPInputRequiredError,
+	MCPInvalidResultTypeError,
+	MCPProtocolError,
+} from './errors.js'
+
+// Era resolution lives beside the client, never inside a transport: stdio
+// and HTTP share the whole state machine and differ only in the probe, so
+// a transport that owned a copy would strand the other one.
+export {
+	classifyModernHttpFailure,
+	createMcpEraCache,
+	defaultMcpEraCache,
+	isRecognizedModernError,
+	mcpEraCacheKey,
+	resolveMcpEra,
+} from './era.js'
+export type {
+	McpEraProbe,
+	McpEraProbeAnswer,
+	McpEraResolution,
+	McpEraResolutionInput,
+} from './era.js'
+export { buildEnvelope, decodeResult, encodeMcpHeaderValue } from './envelope.js'
+export type { McpEnvelope, McpEnvelopeInput, MCPDecodedResult } from './envelope.js'
+
+// The repo's first refusal path: a tool definition namzu declines to expose.
+// Exported so a host can ask the same question of a schema it holds — and
+// because `McpEnvelopeInput.paramHeaders` names the binding type.
+export { validateMcpHeaderAnnotations } from './x-mcp-header.js'
+export type { McpHeaderAnnotationVerdict, McpParamHeaderBinding } from './x-mcp-header.js'
+
 export {
 	mcpToolToToolDefinition,
 	toolDefinitionToMCPTool,

package/src/connector/mcp/streamable-http.ts

@@ -1,4 +1,5 @@
 import type {
+	MCPFetchLike,
 	MCPJsonRpcMessage,
 	MCPStreamableHttpTransportConfig,
 	MCPTransport,
@@ -7,20 +8,44 @@ import type {
 import { SCOPE_ATTRIBUTE } from '../../utils/log/types.js'
 import { type Logger, resolveLogger } from '../../utils/logger.js'
 import { ConnectorHttpOperation, validateConnectorTimeoutMs } from '../http-operation.js'
+import { MCPHttpStatusError } from './errors.js'
 import { refuseMcpHttpRedirect } from './http-redirect.js'
 
 const DEFAULT_TIMEOUT_MS = 30_000
 
+/**
+ * How long a best-effort session teardown DELETE is given before this
+ * transport stops tracking it.
+ *
+ * `close()` never awaits this at all — the bound exists only so a DELETE to
+ * an unresponsive peer does not accumulate as a dangling request forever.
+ */
+const SESSION_DELETE_TIMEOUT_MS = 5_000
+
 export class StreamableHttpTransport implements MCPTransport {
 	private messageHandlers: Array<(message: MCPJsonRpcMessage) => void> = []
 	private closeHandlers: Array<() => void> = []
 	private errorHandlers: Array<(error: Error) => void> = []
 	private connected = false
 	private sessionId: string | null = null
+	/**
+	 * The most recent SSE event `id` this transport has seen, if any.
+	 *
+	 * Legacy-only in effect, never in name: this transport only ever holds a
+	 * `sessionId` on a legacy connection (a modern connection has no
+	 * `initialize` reply to capture one from — `MCPClient` probes with
+	 * `server/discover` instead), and {@link buildHeaders} sends
+	 * `Last-Event-ID` only alongside a session id. Deliberately NOT cleared
+	 * by `close()`: the whole point is arming the header for the request
+	 * that follows a reconnect, once a fresh session exists to carry it.
+	 */
+	private lastEventId: string | null = null
 	private generation = 0
 	private activeSends = new Set<AbortController>()
 	private log: Logger
 	private readonly timeoutMs: number
+	/** Defaults to the ambient global `fetch`; never read again once captured. */
+	private readonly fetchImpl: MCPFetchLike
 
 	constructor(
 		private readonly config: MCPStreamableHttpTransportConfig,
@@ -30,6 +55,7 @@ export class StreamableHttpTransport implements MCPTransport {
 			config.timeoutMs ?? DEFAULT_TIMEOUT_MS,
 			'StreamableHttpTransport timeoutMs',
 		)
+		this.fetchImpl = config.fetch ?? fetch
 		this.log = resolveLogger(log).child({ [SCOPE_ATTRIBUTE]: 'connector/mcp/streamable-http' })
 	}
 
@@ -41,22 +67,94 @@ export class StreamableHttpTransport implements MCPTransport {
 	}
 
 	async close(): Promise<void> {
+		// Read and clear before anything else can observe or re-enter: whatever
+		// happens below, this transport no longer believes it holds this session.
+		const sessionId = this.sessionId
+		this.sessionId = null
+
 		if (!this.connected) {
 			// Never connected, or already closed: nothing will notify, so this is
 			// the only chance to drop what `connect()` registered before it failed.
 			this.clearHandlers()
-			this.sessionId = null
+			if (sessionId) this.sendSessionDelete(sessionId)
 			return
 		}
 		this.connected = false
 		this.generation++
-		this.sessionId = null
 		const reason = new Error('StreamableHttpTransport closed')
 		for (const controller of this.activeSends) controller.abort(reason)
 		this.activeSends.clear()
 		for (const handler of this.closeHandlers) handler()
 		// After the notification, never before it.
 		this.clearHandlers()
+		if (sessionId) this.sendSessionDelete(sessionId)
+	}
+
+	/**
+	 * Forget the session this transport has been attaching to requests,
+	 * without otherwise disturbing the connection.
+	 *
+	 * Used by `MCPClient`'s legacy session-recovery path: a `404` on a
+	 * request means the server has forgotten this session, and the spec's
+	 * remedy is a fresh `initialize` sent with no session id attached — which
+	 * only happens if this transport stops sending the stale one first.
+	 */
+	resetSession(): void {
+		this.sessionId = null
+	}
+
+	/** Whether this transport is currently attaching a session id to its requests. */
+	hasSession(): boolean {
+		return this.sessionId !== null
+	}
+
+	/**
+	 * Tell the peer this session is done, without making `close()` wait on
+	 * the answer.
+	 *
+	 * A SHOULD, not a MUST: it lets a cooperative server free resources
+	 * promptly instead of waiting out its own idle timeout, but a server that
+	 * never hears it is no worse off than before this existed. Fire-and-forget
+	 * on purpose — `close()`'s existing bounded-teardown guarantee must not
+	 * grow a dependency on a round trip to a peer that may already be gone —
+	 * and bounded by its own short timeout so a peer that never answers does
+	 * not leave a request open indefinitely. A modern origin never reaches
+	 * this: it never had a session id to send in the first place.
+	 */
+	private sendSessionDelete(sessionId: string): void {
+		const controller = new AbortController()
+		const timer = setTimeout(() => {
+			controller.abort(new Error('MCP session DELETE timed out'))
+		}, SESSION_DELETE_TIMEOUT_MS)
+		timer.unref?.()
+		const headers: Record<string, string> = {
+			...this.config.headers,
+			'Mcp-Session-Id': sessionId,
+		}
+		let sending: Promise<Response>
+		try {
+			sending = this.fetchImpl(this.config.url, {
+				method: 'DELETE',
+				headers,
+				redirect: 'manual',
+				signal: controller.signal,
+			})
+		} catch (err) {
+			clearTimeout(timer)
+			this.log.debug('Failed to send MCP legacy session DELETE', {
+				'namzu.mcp.url': this.config.url,
+				'exception.message': err instanceof Error ? err.message : String(err),
+			})
+			return
+		}
+		void sending
+			.catch((err: unknown) => {
+				this.log.debug('Failed to send MCP legacy session DELETE', {
+					'namzu.mcp.url': this.config.url,
+					'exception.message': err instanceof Error ? err.message : String(err),
+				})
+			})
+			.finally(() => clearTimeout(timer))
 	}
 
 	/** See {@link StdioTransport} — the same append-only handler leak. */
@@ -80,9 +178,9 @@ export class StreamableHttpTransport implements MCPTransport {
 
 		try {
 			const response = await operation.run(() =>
-				fetch(this.config.url, {
+				this.fetchImpl(this.config.url, {
 					method: 'POST',
-					headers: this.buildHeaders(),
+					headers: this.buildHeaders(options?.headers),
 					body: JSON.stringify(message),
 					redirect: 'manual',
 					signal: operation.signal,
@@ -91,7 +189,12 @@ export class StreamableHttpTransport implements MCPTransport {
 
 			refuseMcpHttpRedirect(response, message.method)
 			if (!response.ok) {
-				throw new Error(`StreamableHttpTransport: HTTP ${response.status}: ${response.statusText}`)
+				throw new MCPHttpStatusError(
+					'StreamableHttpTransport',
+					response.status,
+					response.statusText,
+					await readErrorBody(response, operation),
+				)
 			}
 			this.assertCurrent(owned.generation, operation)
 			// MCP assigns the session during initialize. Letting an ordinary or
@@ -126,15 +229,28 @@ export class StreamableHttpTransport implements MCPTransport {
 		return this.connected
 	}
 
-	private buildHeaders(): Record<string, string> {
+	/**
+	 * `extra` comes from `MCPTransportSendOptions.headers` — the client's
+	 * per-send authority, `MCP-Protocol-Version` today — and is merged over
+	 * this transport's own static config headers so a caller's value wins
+	 * on a collision. `Mcp-Session-Id` is applied after both: it is
+	 * transport-managed state a caller cannot see to conflict with.
+	 */
+	private buildHeaders(extra?: Readonly<Record<string, string>>): Record<string, string> {
 		const headers: Record<string, string> = {
 			'Content-Type': 'application/json',
 			Accept: 'application/json, text/event-stream',
 			...this.config.headers,
+			...extra,
 		}
 
 		if (this.sessionId) {
 			headers['Mcp-Session-Id'] = this.sessionId
+			// Resumption is a legacy-only concept, and gated the same way the
+			// session id itself is: a modern connection never captures a
+			// `sessionId` (see the field's own doc comment), so this branch is
+			// unreachable there without a second, redundant era flag.
+			if (this.lastEventId) headers['Last-Event-ID'] = this.lastEventId
 		}
 
 		return headers
@@ -191,7 +307,7 @@ export class StreamableHttpTransport implements MCPTransport {
 
 		const contentType = response.headers.get('content-type') ?? ''
 		const messages = contentType.includes('text/event-stream')
-			? parseSseMessages(text)
+			? this.parseSseAndCaptureEventId(text)
 			: parseJsonMessages(text)
 
 		for (const message of messages) {
@@ -202,6 +318,41 @@ export class StreamableHttpTransport implements MCPTransport {
 			}
 		}
 	}
+
+	/**
+	 * Parse an SSE body and remember the newest event `id` it carried, if
+	 * any.
+	 *
+	 * The id survives past this one call — see the `lastEventId` field's own
+	 * doc comment — so it is available to arm `Last-Event-ID` on whatever
+	 * request follows a later reconnect.
+	 */
+	private parseSseAndCaptureEventId(raw: string): MCPJsonRpcMessage[] {
+		const { messages, lastEventId } = parseSseMessages(raw)
+		if (lastEventId !== undefined) this.lastEventId = lastEventId
+		return messages
+	}
+}
+
+/**
+ * The body of a failed response, or an empty string.
+ *
+ * Carried on the error rather than discarded, because a status alone cannot
+ * tell a legacy origin from a modern one: a modern server answers an
+ * unknown method with `404` and a JSON-RPC error body precisely so that a
+ * client can tell the two apart. Reading it must never turn a clean HTTP
+ * failure into a different one, so a body that cannot be read is simply
+ * absent — the status error is the real answer either way.
+ */
+async function readErrorBody(
+	response: Response,
+	operation: ConnectorHttpOperation,
+): Promise<string> {
+	try {
+		return await operation.run(() => response.text())
+	} catch {
+		return ''
+	}
 }
 
 function parseJsonMessages(raw: string): MCPJsonRpcMessage[] {
@@ -209,14 +360,51 @@ function parseJsonMessages(raw: string): MCPJsonRpcMessage[] {
 	return Array.isArray(parsed) ? parsed : [parsed]
 }
 
-function parseSseMessages(raw: string): MCPJsonRpcMessage[] {
+/** What one SSE-formatted Streamable HTTP response body parsed into. */
+export interface MCPSseParseResult {
+	readonly messages: MCPJsonRpcMessage[]
+	/**
+	 * The value of the last `id:` field seen across every event in the body
+	 * — including one whose `data:` was empty, SSE's own priming event.
+	 * `undefined` when no event in the body carried an id at all.
+	 */
+	readonly lastEventId?: string
+}
+
+/**
+ * Parse a response body served as `text/event-stream`.
+ *
+ * Exported and pure so it is a direct unit-test target, with no transport,
+ * socket or server needed to see what it decides.
+ *
+ * Already correct on three counts before this: `data:` with or without a
+ * leading space, multi-line data joined with `\n`, and the empty-data
+ * priming event skipped as a message. This adds the two genuinely new
+ * pieces — capturing `id:` (armed by the caller for a legacy
+ * `Last-Event-ID` reconnect) and treating a `:`-prefixed comment or another
+ * unrecognized line as exactly what the spec says it is: not a field, never
+ * malformed input. Neither needed a special case: both filters below already
+ * select a line by its OWN prefix and so already ignore anything else — a
+ * comment, an `event:` line, a `retry:` line — without one.
+ */
+export function parseSseMessages(raw: string): MCPSseParseResult {
 	const normalized = raw.replace(/\r\n/g, '\n')
 	const events = normalized.split(/\n\n+/)
 	const messages: MCPJsonRpcMessage[] = []
+	let lastEventId: string | undefined
 
 	for (const event of events) {
-		const dataLines = event
-			.split('\n')
+		const lines = event.split('\n')
+
+		const idLines = lines
+			.filter((line) => line.startsWith('id:'))
+			.map((line) => line.slice('id:'.length).trim())
+		// The LAST `id:` field within one event wins, per SSE's own
+		// field-processing rules — relevant only for a malformed event that
+		// repeats the field, but cheap to get right.
+		if (idLines.length > 0) lastEventId = idLines.at(-1)
+
+		const dataLines = lines
 			.filter((line) => line.startsWith('data:'))
 			.map((line) => line.slice('data:'.length).trimStart())
 
@@ -233,5 +421,5 @@ function parseSseMessages(raw: string): MCPJsonRpcMessage[] {
 		}
 	}
 
-	return messages
+	return lastEventId !== undefined ? { messages, lastEventId } : { messages }
 }