senado-br-mcp 3.7.0 → 3.10.0

package/README.md

@@ -6,7 +6,7 @@
 [![CI](https://github.com/SidneyBissoli/senado-br-mcp-cloudflare/actions/workflows/ci.yml/badge.svg)](https://github.com/SidneyBissoli/senado-br-mcp-cloudflare/actions/workflows/ci.yml)
 [![MCP Registry](https://img.shields.io/badge/MCP-Registry-blue)](https://registry.modelcontextprotocol.io)
 [![LobeHub](https://lobehub.com/badge/mcp/sidneybissoli-senado-br-mcp-cloudflare)](https://lobehub.com/mcp/sidneybissoli-senado-br-mcp-cloudflare)
-[![smithery badge](https://smithery.ai/badge/sidneybissoli/senado-br-mcp-cloudflare)](https://smithery.ai/servers/sidneybissoli/senado-br-mcp-cloudflare)
+[![LightNow capabilities](https://lightnow.ai/badge/io.github.SidneyBissoli/senado-br-mcp-cloudflare)](https://lightnow.ai/servers/io.github.SidneyBissoli/senado-br-mcp-cloudflare)
 [![senado-br-mcp-cloudflare MCP server](https://glama.ai/mcp/servers/SidneyBissoli/senado-br-mcp-cloudflare/badges/score.svg)](https://glama.ai/mcp/servers/SidneyBissoli/senado-br-mcp-cloudflare)
 [![GitHub stars](https://img.shields.io/github/stars/SidneyBissoli/senado-br-mcp-cloudflare?style=flat&logo=github)](https://github.com/SidneyBissoli/senado-br-mcp-cloudflare)
 [![GitHub Sponsors](https://img.shields.io/github/sponsors/SidneyBissoli?logo=githubsponsors&label=Sponsor&color=db61a2)](https://github.com/sponsors/SidneyBissoli)
@@ -148,7 +148,7 @@ Claude Code auto-discovers it when you work in this repo. To use it elsewhere, c
 - **Runtime:** Cloudflare Workers (ESM)
 - **Transport:** Streamable HTTP (MCP spec 2025-03-26) via `createMcpHandler` from `agents/mcp`
 - **Protocol:** MCP over JSON-RPC — `/mcp` handles the full public server; `/mcp/openai-app-v2` exposes a curated 27-tool profile plus a shared MCP Apps widget for OpenAI app review/submission (`/mcp/openai-app` remains as a legacy alias)
-- **SDK:** `@modelcontextprotocol/sdk` 1.26.0+ (per-request McpServer instances)
+- **SDK:** `@modelcontextprotocol/server` 2.x (per-request McpServer instances; the v1 `@modelcontextprotocol/sdk` remains only as a peer of `agents`, dev-time)
 - **Validation:** Zod schemas for all tool inputs
 - **Caching:** 2-layer (L0 memory + L1 Cache API) with SHA-256 keying
 - **e-Cidadania store:** D1 database refreshed by a Cron Trigger (every 2h) — list tools read from D1 with a live-scrape fallback and a staleness flag; detail tools stay live with write-through (see [e-Cidadania](#e-cidadania-d1-backed-cron-refreshed))

package/README.pt-BR.md

@@ -149,7 +149,7 @@ O Claude Code a descobre automaticamente ao trabalhar neste repositório. Para u
 - **Runtime:** Cloudflare Workers (ESM)
 - **Transporte:** Streamable HTTP (spec MCP 2025-03-26) via `createMcpHandler` de `agents/mcp`
 - **Protocolo:** MCP sobre JSON-RPC — `/mcp` serve o catalogo publico completo; `/mcp/openai-app-v2` expoe um perfil curado de 27 ferramentas mais um widget MCP Apps compartilhado para revisao/submissao como app OpenAI (`/mcp/openai-app` permanece como alias legado)
-- **SDK:** `@modelcontextprotocol/sdk` 1.26.0+ (instâncias de McpServer por requisição)
+- **SDK:** `@modelcontextprotocol/server` 2.x (instâncias de McpServer por requisição; o `@modelcontextprotocol/sdk` v1 fica só como peer do `agents`, em tempo de dev)
 - **Validação:** schemas Zod para todas as entradas das ferramentas
 - **Cache:** 2 camadas (L0 memória + L1 Cache API) com chaveamento SHA-256
 - **Store do e-Cidadania:** banco D1 atualizado por um Cron Trigger (a cada 2h) — as ferramentas de listagem leem do D1 com fallback de scraping ao vivo e flag de desatualização; as de detalhe ficam ao vivo com write-through (veja [e-Cidadania](#e-cidadania-em-d1-atualizado-por-cron))

package/dist/app-surface.js

@@ -1,6 +1,11 @@
 export const DEFAULT_MCP_ROUTE = "/mcp";
 export const OPENAI_APP_LEGACY_MCP_ROUTE = "/mcp/openai-app";
 export const OPENAI_APP_MCP_ROUTE = "/mcp/openai-app-v2";
+// Rota privada do dono: mesma superficie COMPLETA da rota publica, outro
+// endereco, e a telemetria a marca como uso proprio (ver src/instrument.ts).
+// Precisa ser reconhecida aqui, senao handlerRouteForPath cai no fallback e
+// o handler e montado numa rota diferente da que a requisicao pediu.
+export const SELF_MCP_ROUTE = "/mcp/uso-proprio";
 export const OPENAI_APP_WIDGET_URI = "ui://senado-br-mcp/openai-app-dashboard-v2.html";
 export const OPENAI_APP_WIDGET_DOMAIN = "https://senado.sidneybissoli.com";
 const OPENAI_APP_MCP_ROUTES = new Set([OPENAI_APP_LEGACY_MCP_ROUTE, OPENAI_APP_MCP_ROUTE]);
@@ -89,7 +94,9 @@ export function mcpRouteForProfile(profile) {
 }
 export function handlerRouteForPath(pathname, profile) {
     const normalized = normalizeMcpRoute(pathname);
-    if (OPENAI_APP_MCP_ROUTES.has(normalized) || normalized === DEFAULT_MCP_ROUTE) {
+    if (OPENAI_APP_MCP_ROUTES.has(normalized) ||
+        normalized === DEFAULT_MCP_ROUTE ||
+        normalized === SELF_MCP_ROUTE) {
         return pathname;
     }
     return mcpRouteForProfile(profile);

package/dist/call-shape.js

@@ -0,0 +1,215 @@
+/**
+ * A FORMA da chamada, nunca o conteúdo dela.
+ *
+ * Por que existe. Em 10/09/2026 o painel do portfólio passou a medir erro por
+ * chamada e apontou cinco ferramentas quebradas, a pior delas
+ * `senado_reuniao_comissao`, com 74 erros em 74 chamadas. Diagnosticar custou
+ * vinte minutos de chamadas manuais porque a telemetria dizia QUE falhou e não
+ * DIZIA por quê — e a primeira hipótese (o agente escolheu a ferramenta errada,
+ * confundindo o singular com o plural `senado_reunioes_comissao`) estava
+ * ERRADA: erro de validação de esquema nem chega aqui, o SDK o responde antes
+ * do callback. As 74 falhas eram códigos bem-formados que não existem.
+ *
+ * Por que não gravar os argumentos. O dado que este servidor serve é público; a
+ * PERGUNTA não é. `senado_ceaps` com o id de um senador, repetido, é alguém
+ * investigando aquele senador, e o registro já guarda país e organização de
+ * rede. Parte dos parâmetros é texto livre (`palavraChave`), onde cabe qualquer
+ * coisa que a pessoa digitou. E ligar isso mudaria o que o serviço coleta sem
+ * mudar o que a página pública diz que ele coleta.
+ *
+ * O meio-termo: NOMES de parâmetro (que são o esquema publicado, não dado de
+ * ninguém) e a CLASSE do erro (vocabulário fechado, derivado da nossa própria
+ * mensagem). Isso separa "chamou sem o parâmetro obrigatório" de "chamou certo
+ * com um valor que não existe" — que é a bifurcação do conserto.
+ */
+/**
+ * Classifica pela mensagem de erro, que é NOSSA. A ordem importa: "não
+ * encontrado" e "vazio" são mais específicos que "erro da fonte", e um 404
+ * casaria com os dois.
+ *
+ * O vocabulário foi ampliado depois de passar o classificador por TODAS as
+ * mensagens de erro do bcb e do senado (a varredura virou a guarda em
+ * `call-shape.test.ts`): 13 de 18 aqui e 12 de 18 lá caíam em `outro`, ou
+ * seja, a telemetria não responderia nada nestes dois servidores. As famílias
+ * que faltavam eram "Informe X ou Y", "só existe para", "desconhecido",
+ * "recusada", "não retornou dados" e "não publica" — nenhuma exótica; a versão
+ * inicial foi escrita a partir das mensagens do senado que eu já tinha lido.
+ */
+export function classifyError(message) {
+    const m = message.toLowerCase();
+    // PRIMEIRO de todos, e de propósito: a rota que não existe na fonte é
+    // defeito NOSSO (montamos um caminho errado), e a palavra que a nomeia —
+    // "inexistente" — cairia em `nao_encontrado` logo abaixo, que é exatamente a
+    // conflação que o conserto de 24/09/2026 desfez na borda da rede. A frase
+    // vem de `MSG_ROTA_INEXISTENTE`; ela não é vocabulário da fonte, é nosso.
+    if (m.includes("defeito do servidor mcp"))
+        return "defeito";
+    // A fronteira de palavra vai só no INÍCIO. Os padrões são RADICAIS
+    // ("vazi", "obrigatóri", "indisponív") justamente porque a flexão muda o
+    // fim: `\bvazi\b` não casa "vazia", e foi assim que "Resposta upstream
+    // vazia" caiu em `fonte` na primeira versão — a palavra que casava era
+    // "upstream". Ordem também importa: "não encontrado" é mais específico que
+    // "erro da fonte", e a mensagem real do senado tem sinal das duas famílias.
+    // "desconhecido"/"unknown" só é sinal de contrato quando qualifica um VALOR
+    // que o chamador passou ("Índice de preços desconhecido: X. Aceitos: ...",
+    // "Unknown dimension(s) for dataflow X"). "Erro desconhecido ao consultar o
+    // calendário do IBGE" e "Unknown error" são o oposto — são justamente o caso
+    // sem classe — e a primeira versão desta ampliação os classificava como
+    // contrato.
+    const valorDesconhecido = /\b(desconhecid|unknown)/.test(m) && !/\b(erro desconhecid|unknown error)/.test(m);
+    if (valorDesconhecido ||
+        /\b(obrigatóri|obrigatori|exige|requer|required|inválid|invalid|validation error|não aceita|nao aceita|no máximo|no maximo|só existe|so existe|recusad)/.test(m) ||
+        // Inglês, das mensagens do ilo, do uis e do medical. `empty query` fica
+        // AQUI e não em nao_encontrado: consulta vazia é parâmetro que falta. Era o
+        // radical `empty` solto que a classificava errado — ele existia para "empty
+        // response", que é outra coisa, e agora está escrito por extenso lá.
+        // "narrow it/the query" e "maximum N per call" são instruções ao chamador:
+        // a resposta não veio porque a chamada precisa mudar, que é contrato.
+        /\b(empty query|not part of|too broad|too many|maximum|narrow (it|the|your)|has no codelist|has no enumerated)/.test(m)) {
+        return "contrato";
+    }
+    if (/\b(não encontrad|nao encontrad|não existe|nao existe|does ?n[o']t exist|not.?found|inexistent|vazi|empty response|empty result|returned empty|sem registros|não retornou dados|nao retornou dados|não publica|nao publica|404)/.test(m) ||
+        // "Nenhum evento encontrado", "nenhuma reunião", "nenhum registro": a forma
+        // varia com o substantivo de cada servidor, então case pelo padrão.
+        /\bnenhum[ao]?s?\b[\s\S]{0,40}\b(encontrad|resultado|registro|dado)/.test(m)) {
+        return "nao_encontrado";
+    }
+    // "Informe X ou Y" é a mensagem canônica de parâmetro que falta — dez delas
+    // no senado, com e sem qualificador na frente ("Para por=senador, informe
+    // 'codigoSenador'"). Fica DEPOIS de "não encontrado" de propósito: é o sinal
+    // mais fraco dos dois, e um "informe um código válido" fechando uma mensagem
+    // de não encontrado não pode sequestrar a classe. Hoje nenhuma mensagem dos
+    // quatro servidores casa com as duas famílias — a ordem existe para a
+    // mensagem que alguém escrever amanhã.
+    if (/\binforme\b/.test(m))
+        return "contrato";
+    // `\b5\d\d\b` e não `5\d\d`: sem a fronteira final, qualquer número com um 5
+    // seguido de dois dígitos casava — um código de reunião "591234" citado na
+    // mensagem virava "erro 5xx". A intenção sempre foi o status HTTP.
+    // A fonte falhou ou demorou. As quatro últimas vieram da fábrica de erros do
+    // ibge, onde caíam em `outro`: ela nomeia a falha de infraestrutura em vez de
+    // usar as palavras genéricas ("Tempo de resposta excedido", não "timeout";
+    // "Serviço em manutenção"; "Erro de conexão"). `erro interno do servidor` vai
+    // com o complemento, porque "erro interno" sozinho pode ser bug nosso.
+    if (/\b(timeout|tempo esgotado|tempo de resposta excedid|excedeu o tempo|indisponív|indisponiv|manutenç|manutenc|erro de conexão|erro de conexao|erro interno do servidor|internal server error|upstream|\b5\d\d\b|payload|too large|grande demais|limite de tamanho)/.test(m)) {
+        return "fonte";
+    }
+    return "outro";
+}
+/**
+ * Nomes dos parâmetros que a chamada trouxe, em ordem, separados por vírgula.
+ * Só os nomes de PRIMEIRO nível e só quando o argumento é objeto simples — o
+ * conteúdo nunca entra. Cortado em 200 caracteres porque blob do Analytics
+ * Engine tem teto de tamanho e um nome de parâmetro longo não vale a linha.
+ */
+export function paramNames(args) {
+    const a = Array.isArray(args) ? args[0] : args;
+    if (!a || typeof a !== "object" || Array.isArray(a))
+        return "";
+    const nomes = Object.keys(a)
+        .filter((k) => a[k] !== undefined)
+        .sort();
+    return nomes.join(",").slice(0, 200);
+}
+/**
+ * Texto de erro de um resultado de tool, para classificar. Vazio quando não há.
+ *
+ * Lê o CAMPO `error` do envelope, não o payload serializado inteiro. O envelope
+ * padrão é `{ error, retryable, hint }`, e o `hint` de erro não recuperável
+ * termina com "a fonte oficial pode estar indisponível" — texto de formulário,
+ * igual em todos. Classificando o payload inteiro, esse "indisponível"
+ * arrastava TODO erro não recuperável para a classe `fonte`. Visto na produção
+ * do senado em 10/09/2026: a mensagem "Não existe reunião com o código X",
+ * que é `nao_encontrado` por definição, foi gravada como `fonte`.
+ */
+export function errorText(result) {
+    if (!result || typeof result !== "object")
+        return "";
+    const r = result;
+    const estruturado = r.structuredContent?.error;
+    if (typeof estruturado === "string")
+        return estruturado;
+    const t = Array.isArray(r.content) ? r.content[0]?.text : undefined;
+    if (typeof t !== "string")
+        return "";
+    try {
+        const j = JSON.parse(t);
+        if (typeof j.error === "string")
+            return j.error;
+    }
+    catch {
+        // Não é o envelope JSON — vale o texto cru (é o caso de outros servidores).
+    }
+    return t;
+}
+/**
+ * Classifica uma exceção que ESCAPOU do handler, tendo o objeto do erro em mãos
+ * e não só a mensagem.
+ *
+ * Por que existe. Em 22/09/2026 o `ibge_cnae` respondia
+ * `Cannot read properties of undefined (reading 'divisao')` a um código de
+ * classe válido — um `TypeError` nosso, nascido de um `[]` da fonte que
+ * atravessou a camada de rede. Nenhum padrão de `classifyError` casa com essa
+ * frase, então ela caía em `outro`, que já era 13 dos 23 erros da ferramenta na
+ * semana. O comentário de `outro` avisava desde o início: *se esta classe
+ * crescer, é sinal de que falta uma classe*. Faltava esta. O conserto nasceu no
+ * `ibge-br-mcp` 5.1.2 e é o mesmo em toda a frota, porque a classe é a mesma.
+ *
+ * O sinal é o TIPO, não a frase, e é por isso que esta função existe separada
+ * de `classifyError`: `TypeError`, `RangeError`, `ReferenceError` e
+ * `SyntaxError` são erros de programa. A fonte não os produz — nós os
+ * produzimos ao supor a forma do que ela respondeu. Classificá-los por
+ * mensagem seria caçar o texto do motor de JS, que muda entre versões de Node.
+ *
+ * `classifyError` fica INTACTA: ela recebe mensagem e continua sendo o caminho
+ * do erro que NÓS escrevemos.
+ */
+export function classifyThrown(error) {
+    if (error instanceof TypeError ||
+        error instanceof RangeError ||
+        error instanceof ReferenceError ||
+        error instanceof SyntaxError) {
+        return "defeito";
+    }
+    return classifyError(error instanceof Error ? error.message : String(error));
+}
+/**
+ * Classe de um erro JSON-RPC do PROTOCOLO, pelo código antes da mensagem.
+ *
+ * POR QUE ELE CHEGA AQUI AGORA. Até 24/09/2026 este arquivo só era chamado de
+ * dentro do handler, com a exceção da tool na mão — e o cabeçalho acima ainda
+ * registra o limite daquele desenho: *erro de validação de esquema NÃO chega a
+ * esta camada; o SDK o responde antes do handler, e a chamada não é contada nem
+ * como chamada nem como erro*. Era verdade, e era o defeito: a recusa de esquema
+ * não gerava linha NENHUMA de telemetria. Medido na produção em 24/09/2026 pela
+ * rota do dono, ela sai como HTTP **200** com `result.isError: true` e sem
+ * código JSON-RPC; e ferramenta inexistente sai como **200** com o código
+ * **−32602** (não −32601, como se supunha). Desde então a telemetria lê o
+ * ENVELOPE da resposta (src/envelope.ts) e estes casos passam a existir.
+ *
+ * Os códigos reservados pela especificação JSON-RPC 2.0 dizem, sem ambiguidade
+ * de idioma, de quem é o conserto:
+ *
+ *  - −32700 parse error, −32600 invalid request, −32601 method not found e
+ *    −32602 invalid params são o CHAMADOR mandando algo que o protocolo
+ *    recusa. É `contrato` — e o painel exclui `contrato` da taxa de erro
+ *    (`eh_recusa_de_contrato()`), porque ferramenta que recusa chamada
+ *    malformada está funcionando;
+ *  - −32603 internal error é erro NOSSO, que escapou. É `defeito`, e por
+ *    decisão do dono em 24/09/2026 ele entra na fila de saúde do painel: sem
+ *    isso passaríamos a medir e continuaríamos a não agir.
+ *
+ * Código fora dessa faixa (erro definido pelo servidor, −32000 e abaixo) cai
+ * na mensagem, que é o caminho de `classifyError`.
+ *
+ * Cópia FIEL de sih-br-mcp/worker/src/call-shape.ts, onde a função estreou:
+ * classe medida por servidor com classificador diferente não é comparável, e
+ * comparar os sete é a razão de existir da seção de saúde do painel.
+ */
+export function classeDoErroRpc(code, message) {
+    if (code === -32700 || code === -32600 || code === -32601 || code === -32602)
+        return "contrato";
+    if (code === -32603)
+        return "defeito";
+    return classifyError(message);
+}

package/dist/envelope.js

@@ -0,0 +1,257 @@
+/**
+ * Leitura do ENVELOPE da resposta — o que transforma "o container devolveu
+ * HTTP 200" em "esta mensagem deu certo / esta falhou, e por quê".
+ *
+ * O PROBLEMA QUE ESTE ARQUIVO RESOLVE, E QUE AQUI É PIOR QUE NO `sih`. A
+ * telemetria deste Worker decide o desfecho pelo HTTP da resposta, e em cima
+ * disso `protocolNamesFromBody` (em src/instrument.ts) tinha a linha `if (status < 400) continue`, com
+ * o comentário "o hook de tools já gravou esta". A reconciliação era por STATUS,
+ * e supunha que 200 implica que o hook gravou. Quando a tool NÃO CHEGA A RODAR
+ * — recusa de esquema do zod, antes do handler — ninguém grava, e o `continue`
+ * fecha a única outra porta. O `sih` carimbava `ok` numa falha: número errado.
+ * Aqui não havia número NENHUM: a chamada não era contada nem como chamada.
+ *
+ * Medido na produção em 24/09/2026, pela rota do dono, no ilo, uis, senado e
+ * bcb — os quatro idênticos, e são DUAS formas, não uma: recusa de esquema sai
+ * HTTP 200 com `result.isError: true` e SEM código JSON-RPC; ferramenta
+ * inexistente sai HTTP 200 com o código −32602 (não −32601). Os dois são 200,
+ * então os dois caíam no `continue`.
+ *
+ * POR QUE NÃO BUFFERIZAR. Este Worker não é proxy — quem produz a resposta é o
+ * `createMcpHandler` aqui dentro —, mas a técnica é a mesma e pelo mesmo motivo:
+ * segurar bytes para ler o fim trocaria um defeito de medição por um defeito de
+ * produto (a lição do `sih`, cuja série de 34 anos leva ~30 s). O corpo é TEADO
+ * (`ReadableStream.tee()`): um ramo segue intocado para o cliente, no mesmo
+ * ritmo de antes, e o outro é lido aqui em `ctx.waitUntil`, depois que a
+ * resposta já saiu.
+ *
+ * O TEE RESOLVE, DE QUEBRA, UM PROBLEMA DE TEMPO. O hook de tools escreve
+ * durante a execução da tool, que num transporte SSE pode terminar DEPOIS de o
+ * handler já ter devolvido a Response. Ler o envelope até o fim do stream é,
+ * por construção, esperar a tool acabar — é só então que se sabe o que o hook
+ * gravou, e a reconciliação por nome (src/instrument.ts) só vale aí.
+ *
+ * REGRA DE OURO DESTE MÓDULO: ele nunca lança e nunca segura bytes. Qualquer
+ * coisa que ele não entenda vira "sem desfecho", e quem chama cai no critério
+ * antigo (o HTTP). Medir pior é aceitável; atrapalhar a resposta do usuário não é.
+ *
+ * DOIS TETOS, pelo mesmo motivo. Um evento SSE acumulado passa de
+ * `MAX_EVENTO_BYTES` → é descartado sem parsear (o `isError` pode estar no fim
+ * do JSON, mas mensagem de erro é curta: evento gigante é quase certamente
+ * resultado feliz, e o teto troca uma classificação improvável por um limite de
+ * memória e de CPU garantido). Mais de `MAX_DESFECHOS` respostas no mesmo corpo
+ * → o resto é ignorado; lote JSON-RPC de verdade tem punhado de mensagens.
+ *
+ * O CAMINHO DE ERRO-MOLE FICA DE FORA, de propósito. Ferramenta que responde
+ * ausência como DADO — uma resposta de SUCESSO cujo payload diz "não há" — está
+ * funcionando, e continua sendo `ok`. O que conta como falha é `isError: true`
+ * ou um erro JSON-RPC, nada mais. (No `sih`, de onde este arquivo vem, isso é a
+ * decisão 38 e seis ferramentas dependem dela; aqui o erro de tool já nasce de
+ * `IlostatUserError` / `IlostatUpstreamError` e vira `isError`.)
+ *
+ * Cópia de sih-br-mcp/worker/src/envelope.ts, porque o classificador não pode
+ * divergir entre os sete. O que muda é só este cabeçalho e o `teeResposta` do
+ * fim, que lá não existe: o `sih` monta a Response do zero a partir do upstream
+ * e teia no caminho; aqui a Response já vem pronta do handler.
+ */
+import { classeDoErroRpc, classifyError, errorText } from "./call-shape.js";
+/** Teto de bytes acumulados por evento SSE (ou por linha) antes de desistir dele. */
+export const MAX_EVENTO_BYTES = 64 * 1024;
+/** Teto de respostas rastreadas por corpo. */
+export const MAX_DESFECHOS = 64;
+/**
+ * Desfecho de uma resposta JSON-RPC, com o `id` que a liga ao pedido.
+ * `null` quando o objeto não é uma resposta identificável:
+ *  - sem `id` (ou `id: null`, que é a resposta a um pedido que nem parseou) —
+ *    não há a que ligar, e o chamador fica com o critério do HTTP;
+ *  - sem `result` e sem `error` — não é resposta (é notificação, ou lixo).
+ */
+export function desfechoDaResposta(msg) {
+    if (!msg || typeof msg !== "object" || Array.isArray(msg))
+        return null;
+    const m = msg;
+    if (typeof m.id !== "string" && typeof m.id !== "number")
+        return null;
+    const id = String(m.id);
+    if (m.error && typeof m.error === "object") {
+        const e = m.error;
+        const code = typeof e.code === "number" ? e.code : undefined;
+        const texto = typeof e.message === "string" ? e.message : "";
+        return { id, desfecho: { erro: true, classe: classeDoErroRpc(code, texto) } };
+    }
+    if (m.result && typeof m.result === "object") {
+        const r = m.result;
+        if (r.isError === true) {
+            return { id, desfecho: { erro: true, classe: classifyError(errorText(m.result)) } };
+        }
+        return { id, desfecho: { erro: false, classe: "" } };
+    }
+    // `result` primitivo (o SDK responde `{}` em alguns métodos, mas nunca um
+    // escalar) ainda é sucesso; o que não é resposta é o objeto sem os dois.
+    if (m.result !== undefined)
+        return { id, desfecho: { erro: false, classe: "" } };
+    return null;
+}
+/**
+ * O desfecho de UMA mensagem do pedido, já com o CRITÉRIO DE RESERVA aplicado.
+ *
+ * Regra: vale o que o envelope disse. Quando o envelope não disse nada — `id`
+ * ausente (notificação), stream cortado, evento grande demais, resposta que
+ * não parseou —, vale o HTTP do container, que era o critério único até
+ * 24/09/2026. Nunca se inventa classe: sem leitura, a classe é "".
+ */
+export function resolveDesfecho(id, desfechos, falhouHttp) {
+    const lido = id === "" ? undefined : desfechos.get(id);
+    return lido ?? { erro: falhouHttp, classe: "" };
+}
+/**
+ * Lê o corpo da resposta aos pedaços e vai colhendo desfechos por `id`.
+ *
+ * Aceita os dois formatos que o transporte Streamable HTTP usa: SSE (`data:`
+ * por evento, evento fechado por linha em branco, várias linhas `data:` do
+ * mesmo evento juntadas por `\n`) e JSON cru (resposta direta, sem stream).
+ * Linhas `event:`, `id:`, `retry:` e comentários (`:`) são ignoradas.
+ */
+export class LeitorDeEnvelope {
+    resto = "";
+    descartandoLinha = false;
+    evento = [];
+    bytesDoEvento = 0;
+    eventoEstourado = false;
+    viuSse = false;
+    cru = "";
+    /** Desfechos colhidos, por `id` de mensagem JSON-RPC. */
+    desfechos = new Map();
+    /** Entrega mais um pedaço de TEXTO já decodificado. Nunca lança. */
+    push(texto) {
+        if (!this.viuSse && this.cru.length < MAX_EVENTO_BYTES)
+            this.cru += texto;
+        this.resto += texto;
+        for (;;) {
+            const quebra = this.resto.indexOf("\n");
+            if (quebra < 0)
+                break;
+            const linha = this.resto.slice(0, quebra);
+            this.resto = this.resto.slice(quebra + 1);
+            if (this.descartandoLinha) {
+                // Fim da linha gigante que foi descartada: o evento inteiro cai junto,
+                // porque o JSON dele está incompleto.
+                this.descartandoLinha = false;
+                this.eventoEstourado = true;
+                continue;
+            }
+            this.linha(linha.endsWith("\r") ? linha.slice(0, -1) : linha);
+        }
+        // Linha sem fim à vista e já maior que o teto: para de acumular em vez de
+        // crescer com o corpo (uma resposta de 34 anos é uma única linha `data:`).
+        if (this.resto.length > MAX_EVENTO_BYTES) {
+            this.resto = "";
+            this.descartandoLinha = true;
+        }
+    }
+    /** Fecha o que ficou pendente. Chamar uma vez, ao fim do stream. */
+    end() {
+        if (this.resto !== "" && !this.descartandoLinha) {
+            const linha = this.resto.endsWith("\r") ? this.resto.slice(0, -1) : this.resto;
+            this.resto = "";
+            this.linha(linha);
+        }
+        this.fechaEvento();
+        // Corpo que nunca teve uma linha `data:` é JSON cru.
+        if (!this.viuSse)
+            this.registra(this.cru);
+    }
+    linha(linha) {
+        if (linha === "") {
+            this.fechaEvento();
+            return;
+        }
+        if (!linha.startsWith("data:"))
+            return;
+        this.viuSse = true;
+        const pedaco = linha.slice(5).replace(/^ /, "");
+        this.bytesDoEvento += pedaco.length;
+        if (this.bytesDoEvento > MAX_EVENTO_BYTES) {
+            this.eventoEstourado = true;
+            this.evento = [];
+            return;
+        }
+        this.evento.push(pedaco);
+    }
+    fechaEvento() {
+        const partes = this.evento;
+        const estourou = this.eventoEstourado;
+        this.evento = [];
+        this.bytesDoEvento = 0;
+        this.eventoEstourado = false;
+        if (estourou || partes.length === 0)
+            return;
+        this.registra(partes.join("\n"));
+    }
+    registra(json) {
+        if (json === "" || this.desfechos.size >= MAX_DESFECHOS)
+            return;
+        let obj;
+        try {
+            obj = JSON.parse(json);
+        }
+        catch {
+            return; // pedaço cortado ao meio, ou não era JSON: fica sem desfecho
+        }
+        for (const item of Array.isArray(obj) ? obj : [obj]) {
+            if (this.desfechos.size >= MAX_DESFECHOS)
+                return;
+            const d = desfechoDaResposta(item);
+            if (d)
+                this.desfechos.set(d.id, d.desfecho);
+        }
+    }
+}
+/**
+ * Consome um stream inteiro e devolve os desfechos por `id`. Nunca lança: se o
+ * stream for cortado no meio (cliente desconectou, container caiu), vale o que
+ * deu para ler até ali e o resto fica sem desfecho.
+ */
+export async function desfechosDoCorpo(corpo) {
+    const leitor = new LeitorDeEnvelope();
+    const decoder = new TextDecoder();
+    const reader = corpo.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value)
+                leitor.push(decoder.decode(value, { stream: true }));
+        }
+        leitor.push(decoder.decode());
+    }
+    catch {
+        // Stream interrompido: o que já foi lido continua valendo.
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // ignorado
+        }
+    }
+    leitor.end();
+    return leitor.desfechos;
+}
+/**
+ * Parte o corpo da resposta em dois: o que vai para o cliente e o que a
+ * telemetria lê. Só isto, e nunca mais que isto — a Response devolvida tem o
+ * mesmo status, o mesmo statusText e os mesmos cabeçalhos da original.
+ *
+ * Resposta sem corpo (204, HEAD, erro montado na borda) devolve `corpo: null` e
+ * a própria Response intacta: não há o que teiar, e `new Response(null, resp)`
+ * seria uma cópia à toa.
+ */
+export function teeResposta(resposta) {
+    if (!resposta.body)
+        return { paraCliente: resposta, paraLeitura: null };
+    const [cliente, leitura] = resposta.body.tee();
+    return { paraCliente: new Response(cliente, resposta), paraLeitura: leitura };
+}