[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_105":106,"_107":108},"routes/embed.x.$handle.$name.$",{"_9":10,"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":-5},"handle","mcpconformance","name","mcp-client-conformance","path","src/connection/stateless.ts","project",{"_22":49,"_11":12,"_35":50,"_51":-5,"_52":44,"_53":54,"_55":54,"_56":-5,"_57":-5,"_58":59,"_60":61,"_62":34,"_63":-5,"_64":-5,"_65":38,"_66":67,"_68":-5,"_69":-5,"_70":-5,"_71":-5,"_72":73,"_74":73,"_75":76,"_77":76,"_78":76,"_79":73,"_80":73,"_81":82,"_83":84,"_85":86,"_87":44},"file",{"_22":23,"_11":24,"_25":26,"_27":28,"_29":30,"_31":32,"_33":34,"_35":36,"_37":38,"_39":40,"_41":42,"_43":44,"_45":-5,"_13":46},"permalink","https://www.val.town/x/mcpconformance/mcp-client-conformance/code/src/connection/stateless.ts","extension","id","d9ad4594-332f-4e96-8347-500b6cf9cd75","stateless.ts","fileId","724e2518-ad1b-11f1-951a-1607ee4eb77e","parentId","4f50d5b5-ec03-4323-8192-40bca03f0249","branchId","fdc11199-683b-41f1-a3c5-d5ac53972f86","branchVersion",118,"latest",true,"createdAt",["D",1789046881844],"version",0,"fileType","script","content","/**\n * Stateless connection: 2026-x lifecycle (SEP-2575).\n *\n * No handshake. Every request carries `_meta` with protocolVersion, clientInfo,\n * and clientCapabilities, plus the standard headers (MCP-Protocol-Version,\n * Mcp-Method, Mcp-Name per SEP-2243). Implemented with raw fetch so the\n * conformance suite can test draft spec versions before the SDK supports them.\n *\n * Exports two layers:\n * - `sendStatelessRequest()` — low-level: returns `{status, headers, body,\n * events}` and never throws on JSON-RPC errors. Scenarios that assert on\n * HTTP status or error codes use this directly.\n * - `connectStateless()` — high-level: a `Connection` whose `request()` calls\n * `sendStatelessRequest()` and throws `JsonRpcError` on error responses.\n * The runner picks this via `connectFor()` for `--spec-version draft`.\n *\n * Both build their requests through `buildStandardHeaders()` and\n * `withRequestMeta()` so a strictly-conformant server never rejects harness\n * traffic for reasons unrelated to the behaviour under test\n * (issues #311, #312, #315).\n */\n\nimport { DRAFT_PROTOCOL_VERSION, type SpecVersion } from '../types.ts';\nimport type { JSONRPCNotification } from '../spec-types/2025-11-25.ts';\nimport { validateWireMessage } from '../validation/wire-schema.ts';\nimport { JsonRpcError, type Connection, type ConnectOptions } from './index.ts';\n\nexport interface JsonRpcResponse {\n jsonrpc: '2.0';\n id: number | string | null;\n result?: Record;\n error?: { code: number; message: string; data?: unknown };\n}\n\nexport const CONFORMANCE_CLIENT_INFO = {\n name: 'conformance-test-client',\n version: '1.0.0'\n} as const;\n\nexport const DEFAULT_CLIENT_CAPABILITIES = {\n sampling: {},\n elicitation: {},\n roots: { listChanged: true }\n} as const;\n\nexport interface StatelessResponse {\n status: number;\n headers: Headers;\n contentType?: string;\n /** The parsed JSON-RPC message (for SSE: the event matching the request id). */\n body?: JsonRpcResponse;\n /** All parsed events when the response was an SSE / chunked stream. */\n events?: unknown[];\n /** Raw response text when it could not be parsed as JSON. */\n text?: string;\n}\n\nlet nextRequestId = 1;\n\n/**\n * The `Mcp-Name` source field per SEP-2243: `params.name` for tools/call and\n * prompts/get, `params.uri` for resources/read, `params.taskId` for the\n * SEP-2663 tasks methods (`tasks/get`, `tasks/update`, `tasks/cancel`).\n * Absent otherwise.\n */\nexport function mcpNameForRequest(\n method: string,\n params?: Record\n): string | undefined {\n if (method === 'tools/call' || method === 'prompts/get') {\n return typeof params?.name === 'string' ? params.name : undefined;\n }\n if (method === 'resources/read') {\n return typeof params?.uri === 'string' ? params.uri : undefined;\n }\n if (\n method === 'tasks/get' ||\n method === 'tasks/update' ||\n method === 'tasks/cancel'\n ) {\n return typeof params?.taskId === 'string' ? params.taskId : undefined;\n }\n return undefined;\n}\n\n/**\n * Build the conformant header set for a stateless request: Content-Type,\n * Accept (both content types), MCP-Protocol-Version, Mcp-Method and (when the\n * method carries one) Mcp-Name. `options.headers` overrides or extends the\n * defaults, replacing any default whose name matches case-insensitively.\n * `options.specVersion` sets the MCP-Protocol-Version header (default: draft),\n * so scenarios can send the spec version the run was invoked with.\n */\nexport function buildStandardHeaders(\n method: string,\n params?: Record,\n options: { headers?: Record; specVersion?: SpecVersion } = {}\n): Record {\n const headers: Record = {\n 'Content-Type': 'application/json',\n Accept: 'application/json, text/event-stream',\n 'MCP-Protocol-Version': options.specVersion ?? DRAFT_PROTOCOL_VERSION,\n 'Mcp-Method': method\n };\n const name = mcpNameForRequest(method, params);\n if (name !== undefined) {\n headers['Mcp-Name'] = name;\n }\n\n if (options.headers) {\n for (const [key, value] of Object.entries(options.headers)) {\n // Replace any default that differs only by case, then set the override.\n for (const existing of Object.keys(headers)) {\n if (existing.toLowerCase() === key.toLowerCase()) {\n delete headers[existing];\n }\n }\n headers[key] = value;\n }\n }\n\n return headers;\n}\n\n/**\n * Merge params with the conformant `_meta` required on every stateless\n * request. Keys already present in `params._meta` win over the defaults.\n * `specVersion` sets the declared protocolVersion (default: draft).\n */\nexport function withRequestMeta(\n params?: Record,\n specVersion: SpecVersion = DRAFT_PROTOCOL_VERSION\n): Record {\n return {\n ...params,\n _meta: {\n 'io.modelcontextprotocol/protocolVersion': specVersion,\n 'io.modelcontextprotocol/clientInfo': CONFORMANCE_CLIENT_INFO,\n 'io.modelcontextprotocol/clientCapabilities': DEFAULT_CLIENT_CAPABILITIES,\n ...(params?._meta as Record | undefined)\n }\n };\n}\n\nfunction isJsonRpcResponseShaped(event: unknown): event is JsonRpcResponse {\n return (\n typeof event === 'object' &&\n event !== null &&\n ('result' in event || 'error' in event)\n );\n}\n\nfunction parseSseLineInto(events: unknown[], rawLine: string): void {\n const line = rawLine.trim();\n if (!line) return;\n const jsonText = line.startsWith('data:')\n ? line.replace(/^data:\\s*/, '')\n : line;\n try {\n events.push(JSON.parse(jsonText));\n } catch {\n // Non-JSON line (comments, partial frames) — ignore.\n }\n}\n\n/**\n * Read an SSE / chunked-stream response incrementally and resolve as soon as\n * the JSON-RPC response matching `requestId` arrives, without waiting for the\n * stream to close. If the stream ends (or is aborted) first, returns whatever\n * events were parsed, with `body` set to the last response-shaped event.\n */\nexport async function readSseJsonRpcResponse(\n res: Response,\n requestId: number | string | null\n): Promise<{ events: unknown[]; body?: JsonRpcResponse }> {\n const events: unknown[] = [];\n const matchesRequest = (event: unknown): event is JsonRpcResponse =>\n isJsonRpcResponseShaped(event) && event.id === requestId;\n const finish = (): { events: unknown[]; body?: JsonRpcResponse } => {\n const match = events.find(matchesRequest);\n const lastResponseShaped = [...events]\n .reverse()\n .find(isJsonRpcResponseShaped);\n return { events, body: match ?? lastResponseShaped };\n };\n\n if (!res.body) return finish();\n\n const reader = res.body.getReader();\n const decoder = new TextDecoder();\n let buffer = '';\n\n try {\n for (;;) {\n let value: Uint8Array | undefined;\n let done = false;\n try {\n ({ value, done } = await reader.read());\n } catch {\n // The stream was aborted (timeout) or dropped — return what arrived.\n break;\n }\n\n if (value) {\n buffer += decoder.decode(value, { stream: true });\n const lines = buffer.split(/\\r?\\n/);\n buffer = lines.pop() ?? '';\n for (const line of lines) parseSseLineInto(events, line);\n\n if (events.some(matchesRequest)) {\n // The response we were waiting for arrived; stop reading the stream.\n await reader.cancel().catch(() => {});\n break;\n }\n }\n\n if (done) {\n parseSseLineInto(events, buffer);\n buffer = '';\n break;\n }\n }\n } finally {\n try {\n reader.releaseLock();\n } catch {\n // Lock already released (e.g. after cancel) — nothing to do.\n }\n }\n\n return finish();\n}\n\n/**\n * Send a single stateless JSON-RPC request with the full set of cross-cutting\n * headers and `_meta`. Handles both JSON and SSE responses.\n */\nexport async function sendStatelessRequest(\n serverUrl: string,\n method: string,\n params?: Record,\n options: {\n headers?: Record;\n timeoutMs?: number;\n specVersion?: SpecVersion;\n /** Skip wire-schema validation of the *outgoing request* only (for intentionally\n * malformed traffic). Responses stay validated, with one carve-out: JSON-RPC 2.0\n * requires `id: null` on errors for unprocessable requests, which RequestId forbids. */\n skipValidation?: boolean;\n } = {}\n): Promise {\n const id = nextRequestId++;\n const specVersion = options.specVersion ?? DRAFT_PROTOCOL_VERSION;\n const headers = buildStandardHeaders(method, params, {\n headers: options.headers,\n specVersion: options.specVersion\n });\n const request = {\n jsonrpc: '2.0',\n id,\n method,\n params: withRequestMeta(params, options.specVersion)\n };\n if (!options.skipValidation) {\n validateWireMessage(specVersion, request, {\n origin: 'harness',\n context: `stateless request '${method}'`\n });\n }\n const body = JSON.stringify(request);\n\n // See the `skipValidation` doc above: on a skip-validated request, tolerate the\n // JSON-RPC 2.0 `id: null` an error response must carry when the request could not be\n // processed, by validating the rest of the shape with the request's real id substituted.\n const withNullIdCarveOut = (event: unknown): unknown => {\n if (\n options.skipValidation &&\n typeof event === 'object' &&\n event !== null &&\n (event as Record).error !== undefined &&\n (event as Record).id === null\n ) {\n return { ...(event as Record), id };\n }\n return event;\n };\n\n const controller = new AbortController();\n const timeout = setTimeout(\n () => controller.abort(),\n options.timeoutMs ?? 10000\n );\n try {\n const res = await fetch(serverUrl, {\n method: 'POST',\n headers,\n body,\n signal: controller.signal\n });\n\n const contentType = res.headers.get('content-type') ?? undefined;\n\n if (contentType?.includes('text/event-stream')) {\n // Read the stream incrementally and resolve on the matching response —\n // a server that keeps the stream open must not stall the harness.\n const { events, body: matched } = await readSseJsonRpcResponse(res, id);\n for (const event of events) {\n validateWireMessage(specVersion, withNullIdCarveOut(event), {\n origin: 'implementation',\n context: `SSE event during '${method}'`,\n requestMethod: event === matched ? method : undefined\n });\n }\n return {\n status: res.status,\n headers: res.headers,\n contentType,\n events,\n body: matched\n };\n }\n\n const text = await res.text();\n try {\n const parsed = text ? (JSON.parse(text) as JsonRpcResponse) : undefined;\n if (parsed !== undefined) {\n validateWireMessage(specVersion, withNullIdCarveOut(parsed), {\n origin: 'implementation',\n context: `response to '${method}'`,\n requestMethod: method\n });\n }\n return {\n status: res.status,\n headers: res.headers,\n contentType,\n body: parsed\n };\n } catch {\n return { status: res.status, headers: res.headers, contentType, text };\n }\n } finally {\n clearTimeout(timeout);\n // Tear down any still-open SSE stream so sockets don't linger.\n controller.abort();\n }\n}\n\n/**\n * `Connection` impl for the 2026-x stateless lifecycle. Thin wrapper over\n * `sendStatelessRequest()`: classifies SSE-stream events into the notification\n * sink, surfaces server→client *requests* on the response stream as a spec\n * violation, and throws `JsonRpcError` on error responses.\n *\n * Session bootstrap on the stateless wire is `server/discover` (SEP-2575's\n * replacement for `initialize`). The result is exposed via\n * `connection.discover()` so scenarios can inspect server capabilities,\n * serverInfo, and supported protocol versions.\n */\nexport async function connectStateless(\n serverUrl: string,\n specVersion: SpecVersion = DRAFT_PROTOCOL_VERSION,\n opts: ConnectOptions = {}\n): Promise {\n const notifications: JSONRPCNotification[] = [];\n const capabilities = opts.capabilities ?? DEFAULT_CLIENT_CAPABILITIES;\n const clientInfo = opts.clientInfo ?? CONFORMANCE_CLIENT_INFO;\n\n // The Connection layer is the single place that knows about\n // connect-time capabilities / clientInfo. We fold them into the\n // request's `_meta` here (the trailing `params._meta` spread in\n // `withRequestMeta` lets us override its defaults) so that\n // `sendStatelessRequest` and `withRequestMeta` keep their upstream\n // signatures untouched.\n function withConnectMeta(\n params?: Record\n ): Record {\n return {\n ...params,\n _meta: {\n 'io.modelcontextprotocol/clientCapabilities': capabilities,\n 'io.modelcontextprotocol/clientInfo': clientInfo,\n ...(params?._meta as Record | undefined)\n }\n };\n }\n\n async function send(\n method: string,\n params?: Record,\n extraHeaders?: Record\n ): Promise {\n return sendStatelessRequest(serverUrl, method, withConnectMeta(params), {\n specVersion,\n headers: extraHeaders\n });\n }\n\n function drainEvents(response: StatelessResponse): void {\n for (const event of response.events ?? []) {\n if (typeof event !== 'object' || event === null) continue;\n if ('method' in event && !('id' in event)) {\n notifications.push(event as JSONRPCNotification);\n } else if ('method' in event && 'id' in event) {\n throw new JsonRpcError(\n -32600,\n `Server sent request '${(event as { method: string }).method}' on response stream; stateless lifecycle forbids this (use MRTR)`\n );\n }\n }\n }\n\n function unwrap(method: string, response: StatelessResponse): R {\n const rpcError = response.body?.error;\n // Only a properly-shaped JSON-RPC error becomes a JsonRpcError; anything\n // else (e.g. a proxy's `{\"error\": \"upstream timeout\"}`) falls through so\n // the HTTP status and raw body are surfaced below.\n if (\n typeof rpcError === 'object' &&\n rpcError !== null &&\n typeof rpcError.code === 'number'\n ) {\n throw new JsonRpcError(rpcError.code, rpcError.message, rpcError.data);\n }\n if (response.body?.result === undefined) {\n throw new Error(\n `HTTP ${response.status}: ` +\n `expected a JSON-RPC result for '${method}', got ` +\n (response.text !== undefined\n ? `non-JSON body (content-type ${response.contentType ?? '(none)'})`\n : response.body !== undefined\n ? `unexpected body ${JSON.stringify(response.body)}`\n : 'no result in response body')\n );\n }\n return response.body.result as R;\n }\n\n // SEP-2575 has no required handshake. `_meta.clientCapabilities` on\n // every request is authoritative per spec, so `server/discover` is\n // strictly a client-side query (\"what does the server advertise?\").\n // We deliberately do NOT run it eagerly — a server that ignores\n // per-request `_meta` until a prior `server/discover` has registered\n // the session is non-conformant, and the conformance suite's job is\n // to surface that, not paper over it.\n let discoverPromise: Promise> | undefined;\n\n async function request(\n method: string,\n params?: Record,\n extraHeaders?: Record\n ): Promise {\n const response = await send(method, params, extraHeaders);\n drainEvents(response);\n return unwrap(method, response);\n }\n\n return {\n notifications,\n discover(): Promise> {\n return (discoverPromise ??=\n request>('server/discover'));\n },\n request,\n close: async () => {}\n };\n}\n","deleted",false,"label",[47,48,24],"src","connection","7dcb6042-d92f-40c5-9cc8-0f661f96e58b",["D",1789043604380],"deletedAt","legacyEnvVars","privacy","public","httpPrivacy","description","imageUrl","userId","f4518a30-f52b-4b12-891c-a8fffb7240f8","pinnedFileId","e6dd13e2-ad13-11f1-a612-1607ee4eb77e","pinPreview","pinMigrated","screenshotVersion","likeCount","orgId","01a07c12-b73a-76de-b96a-421ce8582af6","tursoName","tursoHostname","tursoMeasuredAt","pinned","userPerm","r","valPerm","blobPerm","rw","emailPerm","sqlitePerm","projectPerm","telemetryPerm","user",{"_9":10,"_104":-5},"org",{"_9":10,"_98":99,"_100":-5,"_58":-5,"_101":102,"_103":44},"branch",{"_37":88,"_11":89,"_22":30,"_90":49,"_91":-5,"_92":-5,"_93":-5,"_94":-5,"_95":-5,"_96":12,"_97":10},"isOwned",396,"main","projectId","forkedBranchId","forkedBranchVersion","forkedProjectPrivacy","forkedProjectId","forkedProjectOrgId","projectName","userHandle","displayName","MCP Conformance","avatar","tier","free","canRestrictVals","profileImageUrl","ctx",{"_81":-5,"_138":139,"_140":141,"_142":143,"_144":44,"_145":44,"_146":44,"_147":34,"_148":-5,"_149":-7,"_150":-7,"_151":38,"_152":44,"_153":44,"_154":-5,"_155":44,"_156":44,"_157":44,"_158":-5},"ENV",{"_109":110,"_111":112,"_113":89,"_114":115,"_116":117,"_118":119,"_120":121,"_122":123,"_124":125,"_126":127,"_128":129,"_130":131,"_132":133,"_134":135,"_136":137},"REACT_APP_SENTRY_DSN","https://586020d86f05489db63a554690acf1e9@o1398359.ingest.sentry.io/6724499","RENDER_GIT_COMMIT","e87eb04e707cf64e7e532c8e8ec395f209e17f15","RENDER_GIT_BRANCH","POSTHOG_API_TOKEN","phc_nmoyuAkStEZuUp69rYlg1DZgrIt19Gx0Y4Hwf8tGgJP","POSTHOG_API_HOST","https://wart.val.town","WEB_API_TEMPLATE","https://{val}.web.val.run","APP_URL","https://www.val.town","MODULE_URL","https://esm.town","VANITY_WEB_API_TEMPLATE","https://{label}.val.run/","DENOLS_URL","https://lsp.val.town","NODE_ENV","production","CLOUDFLARE_TURNSTILE_SITE_KEY","0x4AAAAAACtaIZJH7s9rBMZ6","GOOGLE_CLIENT_ID","875989696899-jtsqkhlbdv5jrlsk8631p7ipjg3c6o62.apps.googleusercontent.com","STRIPE_PUBLISHABLE_KEY","pk_live_51N2zvWEpZTTLipIkVEwXrUG9AT0yeOOEYxszarZT1jpsZV58Ly6wlg3SltZpHN26CUalOBmUSY7adQRQiSkCZz2500qSXNkf8Y","API_URL","https://api.val.town","orgs",[],"preferencesKeybindings","default","preferencesTheme","light","preferencesFixers","preferencesCopilot","preferencesSelectionAi","preferencesCloseBrackets","preferencesChatPanelState","preferencesDprint","preferencesDenofmt","notificationCount","flagDenols","isBusinessOrgMember","businessOrgHandle","isBusinessOrgAdmin","isHigherTownieTier","navCollapsed","currentOrgId"]