fg-tracker-sdk 0.11.0 → 0.13.0

package/dist/genai/http.js

@@ -0,0 +1,795 @@
+import { performance } from 'node:perf_hooks';
+import { errorTypeOf, GenAiCall, modelName, reportedCost, tokenCount } from './call.js';
+import { GEN_AI } from './semconv.js';
+import { SseParser } from './sse.js';
+/**
+ * Chamadas de IA por HTTP (OpenAI Chat Completions/Embeddings e compatíveis, Anthropic Messages)
+ * observadas no `fetch` instrumentado (CONTRATO.md §30). Não há span novo: os atributos vão no
+ * `http.client` da própria requisição, que passa a fechar quando a resposta termina.
+ *
+ * Do pedido só saem modelo e parâmetros numéricos; mensagens, prompts de sistema, ferramentas,
+ * identificadores de usuário e o texto das respostas nunca são lidos para atributos.
+ */
+/** Pedido acima disto não é analisado (o modelo vem da resposta): `JSON.parse` roda no caminho da aplicação. */
+const MAX_REQUEST_PARSE_BYTES = 1024 * 1024;
+/** Resposta JSON analisada inteira até aqui; acima, só as chaves da raiz no fim (onde ficam `usage` e `model`). */
+const MAX_RESPONSE_PARSE_BYTES = 1024 * 1024;
+const RESPONSE_TAIL_BYTES = 16 * 1024;
+const MAX_ERROR_BODY_BYTES = 64 * 1024;
+/**
+ * Resposta de erro cujo corpo quem chamou cancela (os clientes OpenAI/Anthropic fazem isso antes de
+ * tentar de novo): a cópia ainda tem até este prazo para ler o código do provedor; depois é cancelada
+ * também e a conexão fecha.
+ */
+const ERROR_BODY_GRACE_MS = 50;
+const RETRY_HEADER = 'x-stainless-retry-count';
+function obj(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+}
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function int(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) ? value : undefined;
+}
+export function isAbortError(err) {
+    const name = err?.name;
+    return name === 'AbortError';
+}
+function safeParse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function requestBodyText(body) {
+    if (typeof body === 'string')
+        return body.length <= MAX_REQUEST_PARSE_BYTES ? body : undefined;
+    if (body instanceof ArrayBuffer)
+        return body.byteLength <= MAX_REQUEST_PARSE_BYTES ? new TextDecoder().decode(body) : undefined;
+    if (ArrayBuffer.isView(body)) {
+        return body.byteLength <= MAX_REQUEST_PARSE_BYTES ? new TextDecoder().decode(new Uint8Array(body.buffer, body.byteOffset, body.byteLength)) : undefined;
+    }
+    return undefined;
+}
+function headerValue(input, init, name) {
+    try {
+        if (init?.headers)
+            return new Headers(init.headers).get(name);
+        return input instanceof Request ? input.headers.get(name) : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Parâmetros do pedido que não são conteúdo. */
+function applyRequest(call, api, body) {
+    if (body.stream === true)
+        call.setRequest(GEN_AI.requestStream, true);
+    const maxTokens = int(body.max_completion_tokens) ?? int(body.max_tokens);
+    call.setRequest(GEN_AI.requestMaxTokens, maxTokens);
+    call.setRequest(GEN_AI.requestTemperature, finite(body.temperature));
+    call.setRequest(GEN_AI.requestTopP, finite(body.top_p));
+    if (api === 'anthropic') {
+        call.setRequest(GEN_AI.requestTopK, finite(body.top_k));
+        return;
+    }
+    if (call.operation === 'embeddings') {
+        if (typeof body.encoding_format === 'string' && body.encoding_format.length <= 32)
+            call.setRequest(GEN_AI.requestEncodingFormats, [body.encoding_format]);
+        return;
+    }
+    call.setRequest(GEN_AI.requestFrequencyPenalty, finite(body.frequency_penalty));
+    call.setRequest(GEN_AI.requestPresencePenalty, finite(body.presence_penalty));
+    call.setRequest(GEN_AI.requestSeed, int(body.seed));
+    const n = int(body.n);
+    if (n !== undefined && n !== 1)
+        call.setRequest(GEN_AI.requestChoiceCount, n);
+    // Índices de escolha acima de 127 não são acompanhados (`setFinishReason`): o teto mantém a conta possível.
+    if (n !== undefined && n >= 1)
+        call.expectedChoices = Math.min(n, 128);
+    const format = obj(body.response_format).type;
+    if (format === 'json_schema' || format === 'json_object')
+        call.setRequest(GEN_AI.outputType, 'json');
+    else if (format === 'text')
+        call.setRequest(GEN_AI.outputType, 'text');
+}
+/**
+ * Prende o estado GenAI ao span `http.client` de uma requisição reconhecida. Lê só o corpo em
+ * texto/bytes já em memória (o SDK da OpenAI e o da Anthropic mandam string); `Request` com corpo
+ * em stream não é lido, e o modelo sai da resposta.
+ */
+export function startHttpGenAiCall(config, span, target, input, init, startedPerf = performance.now()) {
+    const text = requestBodyText(init?.body);
+    const body = text === undefined ? {} : obj(safeParse(text));
+    const call = new GenAiCall(span, config, target.provider, target.operation, startedPerf, modelName(body.model));
+    applyRequest(call, target.api, body);
+    // Retentativa dos clientes Stainless (OpenAI, Anthropic): cada tentativa é um `http.client` próprio.
+    const retry = Number(headerValue(input, init, RETRY_HEADER));
+    if (Number.isSafeInteger(retry) && retry > 0)
+        call.setRequest(GEN_AI.resendCount, retry);
+    return call;
+}
+/**
+ * A requisição falhou antes da resposta (rede, abort). Cancelamento não é erro: vale o `AbortError` e
+ * também o `signal` abortado com motivo próprio (`controller.abort(new Error(...))`), com que o
+ * `fetch` rejeita no lugar do `AbortError`.
+ */
+export function failHttpGenAiCall(call, err, signal) {
+    if (isAbortError(err) || signal?.aborted === true) {
+        call.finish('cancelled');
+        return;
+    }
+    const cause = err?.cause;
+    const name = err?.name;
+    call.errorType = errorTypeOf(cause?.code) ?? (name === 'TimeoutError' ? 'timeout' : errorTypeOf(name)) ?? '_OTHER';
+    call.finish('error', err);
+}
+/* ------------------------------------------------------------------ */
+/* Uso por formato                                                     */
+/* ------------------------------------------------------------------ */
+/** `usage` do Chat Completions/Embeddings (e do OpenRouter): `prompt_tokens` já inclui o cache. */
+function openAiUsage(raw) {
+    const usage = obj(raw);
+    const prompt = obj(usage.prompt_tokens_details);
+    const completion = obj(usage.completion_tokens_details);
+    return {
+        input: tokenCount(usage.prompt_tokens),
+        output: tokenCount(usage.completion_tokens),
+        cacheRead: tokenCount(prompt.cached_tokens),
+        cacheCreation: tokenCount(prompt.cache_write_tokens),
+        reasoning: tokenCount(completion.reasoning_tokens),
+    };
+}
+/** `usage` da Anthropic: `input_tokens` não inclui o cache; a semconv manda somar (anthropic.md). */
+function anthropicInput(usage) {
+    const input = tokenCount(usage.input_tokens);
+    const cacheRead = tokenCount(usage.cache_read_input_tokens);
+    const cacheCreation = tokenCount(usage.cache_creation_input_tokens);
+    return {
+        input: input === undefined ? undefined : input + (cacheRead ?? 0) + (cacheCreation ?? 0),
+        cacheRead,
+        cacheCreation,
+    };
+}
+function setUsage(call, usage) {
+    const merged = { ...call.usage };
+    for (const key of ['input', 'output', 'cacheRead', 'cacheCreation', 'reasoning']) {
+        if (usage[key] !== undefined)
+            merged[key] = usage[key];
+    }
+    call.usage = merged;
+}
+function providerError(call, error, stream) {
+    call.errorType = errorTypeOf(error.code) ?? errorTypeOf(error.type) ?? 'provider_error';
+    // Só o identificador do erro: a mensagem do provedor pode repetir trechos do pedido.
+    call.finish('error', { name: stream ? 'GenAIStreamError' : 'GenAIProviderError', message: `${call.provider}: ${call.errorType}` });
+}
+/** Corpo JSON inteiro de uma resposta 2xx. */
+function applyJson(call, api, body) {
+    if (api === 'anthropic') {
+        if (body.type === 'error')
+            return providerError(call, obj(body.error), false);
+        call.setResponseId(body.id);
+        call.setResponseModel(body.model);
+        call.setFinishReason(0, body.stop_reason);
+        const usage = obj(body.usage);
+        setUsage(call, { ...anthropicInput(usage), output: tokenCount(usage.output_tokens) });
+        call.finish('completed');
+        return;
+    }
+    // OpenRouter devolve alguns erros do provedor como 200 `{ error }`.
+    if (body.error !== undefined && body.error !== null)
+        return providerError(call, obj(body.error), false);
+    call.setResponseId(body.id);
+    call.setResponseModel(body.model);
+    if (Array.isArray(body.choices)) {
+        body.choices.forEach((choice, position) => {
+            const item = obj(choice);
+            call.setFinishReason(int(item.index) ?? position, item.finish_reason);
+        });
+    }
+    if (body.usage !== undefined) {
+        setUsage(call, openAiUsage(body.usage));
+        call.reportedCost = reportedCost(call.provider, obj(body.usage));
+    }
+    call.finish('completed');
+}
+/**
+ * Resposta grande demais para analisar inteira: só `usage` e `model` **da raiz** do objeto, quando
+ * cabem no fim do corpo. Só é chamada quando `JsonShape` provou que o `}` final fecha a raiz. Chave de
+ * mesmo nome dentro de outro valor (argumentos de ferramenta, texto) nunca é lida; o que não dá para
+ * identificar com segurança fica sem atributo.
+ */
+function applyTail(call, api, tail) {
+    const root = rootEntriesFromEnd(tail);
+    call.setResponseModel(root.model);
+    const usage = root.usage;
+    if (usage && typeof usage === 'object' && !Array.isArray(usage)) {
+        const fields = usage;
+        if (api === 'anthropic')
+            setUsage(call, { ...anthropicInput(fields), output: tokenCount(fields.output_tokens) });
+        else {
+            setUsage(call, openAiUsage(fields));
+            call.reportedCost = reportedCost(call.provider, fields);
+        }
+    }
+    call.finish('completed');
+}
+/**
+ * Estado da posição `at`: 0 = não é `"` ou é `"` escapado; 1 = `"` que abre ou fecha string (número
+ * par de barras invertidas antes); 2 = indeterminado, porque as barras chegam ao começo do trecho e
+ * o que vinha antes foi cortado.
+ */
+function quoteState(text, at) {
+    if (text.charCodeAt(at) !== 34)
+        return 0;
+    let k = at - 1;
+    let slashes = 0;
+    while (k >= 0 && text.charCodeAt(k) === 92) {
+        slashes += 1;
+        k -= 1;
+    }
+    if (k < 0)
+        return 2;
+    return slashes % 2 === 0 ? 1 : 0;
+}
+/** Posição da aspa que abre a string fechada em `close`, ou -1 se não der para saber dentro do trecho. */
+function stringStart(text, close) {
+    for (let j = close - 1; j >= 0; j -= 1) {
+        const state = quoteState(text, j);
+        if (state === 1)
+            return j;
+        if (state === 2)
+            return -1;
+    }
+    return -1;
+}
+/**
+ * Pares chave → valor da **raiz** de um objeto JSON lidos de trás para frente a partir do fim do
+ * texto (o fim do corpo), sem precisar do começo. Lendo de trás para frente a partir do `}` final,
+ * sempre se sabe se a posição está dentro de uma string (cada `"` não escapado alterna) e a que
+ * profundidade: só pares na profundidade 1 entram. A leitura para no primeiro ponto que o corte do
+ * trecho deixa ambíguo; o que começa antes dele é ignorado.
+ */
+export function rootEntriesFromEnd(text) {
+    const out = {};
+    let i = text.length - 1;
+    while (i >= 0 && /\s/.test(text[i]))
+        i -= 1;
+    if (text[i] !== '}')
+        return out;
+    let depth = 1;
+    let valueEnd = i; // posição do `,` ou `}` que fecha o valor corrente da raiz
+    i -= 1;
+    while (i >= 0) {
+        const quote = quoteState(text, i);
+        if (quote === 2)
+            return out;
+        if (quote === 1) {
+            // Pula a string inteira até a aspa que a abre.
+            const open = stringStart(text, i);
+            if (open < 0)
+                return out;
+            i = open - 1;
+            continue;
+        }
+        const ch = text.charCodeAt(i);
+        if (ch === 125 || ch === 93)
+            depth += 1;
+        else if (ch === 123 || ch === 91) {
+            depth -= 1;
+            if (depth === 0)
+                return out; // início da raiz
+        }
+        else if (depth === 1 && ch === 44)
+            valueEnd = i;
+        else if (depth === 1 && ch === 58) {
+            // `:` da raiz: a chave é a string logo antes; o valor vai até `valueEnd`.
+            let k = i - 1;
+            while (k >= 0 && /\s/.test(text[k]))
+                k -= 1;
+            if (k < 0 || quoteState(text, k) !== 1)
+                return out;
+            const open = stringStart(text, k);
+            if (open < 0)
+                return out;
+            const key = safeParse(text.slice(open, k + 1));
+            const value = safeParse(text.slice(i + 1, valueEnd));
+            if (typeof key === 'string' && value !== undefined && !Object.prototype.hasOwnProperty.call(out, key))
+                out[key] = value;
+            i = open - 1;
+            continue;
+        }
+        i -= 1;
+    }
+    return out;
+}
+/** Índices de escolha acompanhados (os mesmos de `setFinishReason`). */
+const MAX_CHOICE_INDEX = 127;
+function openAiStream(call) {
+    let first = true;
+    /** Índices de escolha que apareceram no stream e os que já trouxeram `finish_reason`. */
+    const started = new Set();
+    const finished = new Set();
+    return {
+        event({ data }) {
+            call.markFirstChunk();
+            if (data === '[DONE]') {
+                call.finish('completed');
+                return;
+            }
+            // Todo pedaço é lido (são pequenos): os índices das escolhas que começaram decidem se o fim sem
+            // `[DONE]` cortou alguma, mesmo quando o pedido (e o `n`) não pôde ser lido.
+            const chunk = obj(safeParse(data));
+            if (first) {
+                first = false;
+                call.setResponseId(chunk.id);
+                call.setResponseModel(chunk.model);
+            }
+            if (chunk.error !== undefined && chunk.error !== null)
+                return providerError(call, obj(chunk.error), true);
+            if (Array.isArray(chunk.choices)) {
+                for (const [position, choice] of chunk.choices.entries()) {
+                    const item = obj(choice);
+                    if (item.error !== undefined && item.error !== null)
+                        return providerError(call, obj(item.error), true);
+                    const index = int(item.index) ?? position;
+                    const tracked = index >= 0 && index <= MAX_CHOICE_INDEX;
+                    if (tracked)
+                        started.add(index);
+                    if (typeof item.finish_reason === 'string') {
+                        if (tracked)
+                            finished.add(index);
+                        call.setFinishReason(index, item.finish_reason);
+                    }
+                }
+            }
+            if (chunk.usage !== undefined && chunk.usage !== null) {
+                setUsage(call, openAiUsage(chunk.usage));
+                call.reportedCost = reportedCost(call.provider, obj(chunk.usage));
+            }
+        },
+        end() {
+            // Sem `[DONE]` (gateways que fecham o stream direto), só termina se todas as escolhas que
+            // começaram pararam e se pararam tantas quantas o pedido pediu (`n`, quando lido): com uma
+            // escolha cortada, a resposta veio truncada.
+            const allStopped = [...started].every((index) => finished.has(index));
+            call.finish(allStopped && finished.size >= call.expectedChoices ? 'completed' : 'incomplete');
+        },
+    };
+}
+function anthropicStream(call) {
+    let finalUsage = false;
+    const settle = () => {
+        // Sem o `message_delta` com o uso final, só a entrada do `message_start` é conhecida.
+        if (!finalUsage) {
+            call.usage = { input: call.usage.input, cacheRead: call.usage.cacheRead, cacheCreation: call.usage.cacheCreation };
+            call.usagePartial = call.usage.input !== undefined;
+        }
+    };
+    call.onFinish(settle);
+    return {
+        event({ event, data }) {
+            call.markFirstChunk();
+            // `content_block_delta` é a maior parte do stream e só traz texto: nem é analisado.
+            if (event !== 'message_start' && event !== 'message_delta' && event !== 'message_stop' && event !== 'error')
+                return;
+            const payload = obj(safeParse(data));
+            if (event === 'error')
+                return providerError(call, obj(payload.error), true);
+            if (event === 'message_stop') {
+                call.finish('completed');
+                return;
+            }
+            if (event === 'message_start') {
+                const message = obj(payload.message);
+                call.setResponseId(message.id);
+                call.setResponseModel(message.model);
+                setUsage(call, anthropicInput(obj(message.usage)));
+                return;
+            }
+            call.setFinishReason(0, obj(payload.delta).stop_reason);
+            const usage = obj(payload.usage);
+            const output = tokenCount(usage.output_tokens);
+            if (output !== undefined) {
+                finalUsage = true;
+                // Versões recentes repetem a entrada (acumulada) no `message_delta`.
+                const input = anthropicInput(usage);
+                setUsage(call, { ...(input.input !== undefined ? input : {}), output });
+            }
+        },
+        end() {
+            call.finish('incomplete');
+        },
+    };
+}
+function isWebResponse(res) {
+    return typeof Response === 'function' && res instanceof Response && !!res.body && typeof res.body.getReader === 'function';
+}
+/**
+ * Atributos que o construtor de `Response` não copia (`url`, `redirected`, `type`). O `clone()` nativo
+ * os tira do estado interno, que a `Response` nova não tem: o `clone()` dela também os copia, e o
+ * clone de um clone também.
+ */
+function copyResponseIdentity(from, to) {
+    for (const key of ['url', 'redirected', 'type']) {
+        try {
+            Object.defineProperty(to, key, { value: from[key], enumerable: false, configurable: true });
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    const nativeClone = to.clone;
+    if (typeof nativeClone !== 'function')
+        return;
+    try {
+        Object.defineProperty(to, 'clone', {
+            value: function clone() {
+                const copy = nativeClone.call(this);
+                copyResponseIdentity(from, copy);
+                return copy;
+            },
+            enumerable: false,
+            configurable: true,
+            writable: true,
+        });
+    }
+    catch {
+        /* best-effort */
+    }
+}
+function guard(call, fn) {
+    if (call.done)
+        return;
+    try {
+        fn();
+    }
+    catch {
+        // Falha da observação nunca chega à aplicação: o span sai com o que já se sabia.
+        call.finish('unobserved');
+    }
+}
+/**
+ * `Response` equivalente à original (status, headers, `url`) cujo corpo repassa o da original sob
+ * demanda: cada leitura de quem chamou puxa um pedaço (`highWaterMark: 0`, nada lido antes) e
+ * cancelar cancela a original, que fecha a conexão como antes. O corpo é um byte stream, como o do
+ * `fetch`, e aceita também leitor BYOB (`getReader({ mode: 'byob' })`). Cada pedaço segue copiado:
+ * no byte stream o `enqueue` transfere o `ArrayBuffer`, e o da original pode ser compartilhado.
+ * Devolve `null` se não der para montar a `Response`.
+ */
+function relayResponse(res, hooks) {
+    const source = res.body;
+    let reader;
+    const take = () => (reader ??= source.getReader());
+    const stream = new ReadableStream({
+        type: 'bytes',
+        async pull(controller) {
+            for (;;) {
+                let result;
+                try {
+                    result = await take().read();
+                }
+                catch (err) {
+                    hooks.error?.(err);
+                    controller.error(err);
+                    return;
+                }
+                if (result.done) {
+                    hooks.end?.();
+                    try {
+                        controller.close();
+                        // Leitura BYOB pendente só termina com `respond(0)` depois do `close()`.
+                        controller.byobRequest?.respond(0);
+                    }
+                    catch {
+                        /* já cancelado */
+                    }
+                    return;
+                }
+                // Pedaço vazio não pode entrar num byte stream: lê o próximo.
+                if (result.value.byteLength === 0)
+                    continue;
+                hooks.chunk?.(result.value);
+                try {
+                    controller.enqueue(new Uint8Array(result.value));
+                }
+                catch {
+                    /* já cancelado */
+                }
+                return;
+            }
+        },
+        cancel(reason) {
+            hooks.cancel?.(reason);
+            return take().cancel(reason);
+        },
+    });
+    let wrapped;
+    try {
+        wrapped = new Response(stream, { status: res.status, statusText: res.statusText, headers: res.headers });
+    }
+    catch {
+        return null;
+    }
+    copyResponseIdentity(res, wrapped);
+    return wrapped;
+}
+/**
+ * Corpo 2xx observado no caminho da leitura de quem chamou (`relayResponse`): nada é lido antes da
+ * aplicação, e a contrapressão da conexão continua a mesma. Corpo que ninguém lê fica sem
+ * observação e o prazo `observationIdleMs` fecha o span como `unobserved`; cancelar o corpo encerra
+ * o span como `cancelled`.
+ */
+function observeBody(call, res, observer, signal) {
+    const wrapped = relayResponse(res, {
+        chunk(bytes) {
+            if (call.done)
+                return;
+            call.markActivity();
+            guard(call, () => observer.chunk(bytes));
+        },
+        end() {
+            guard(call, () => observer.end());
+        },
+        error(err) {
+            // Abort com motivo próprio faz o corpo rejeitar com esse motivo, não com `AbortError`.
+            guard(call, () => (isAbortError(err) || signal?.aborted === true ? call.finish('cancelled') : failStream(call, err)));
+        },
+        cancel() {
+            guard(call, () => call.finish('cancelled'));
+        },
+    });
+    if (!wrapped) {
+        call.finish('unobserved');
+        return res;
+    }
+    return wrapped;
+}
+/** Stream SSE: os bytes viram eventos para o observador do formato. */
+function sseObserver(call, observer) {
+    const decoder = new TextDecoder();
+    const parser = new SseParser((event) => guard(call, () => observer.event(event)));
+    return {
+        chunk(bytes) {
+            parser.feed(decoder.decode(bytes, { stream: true }));
+        },
+        end() {
+            parser.feed(decoder.decode());
+            parser.end();
+            observer.end();
+        },
+    };
+}
+/**
+ * Corpo JSON: guarda uma cópia até `MAX_RESPONSE_PARSE_BYTES` (os bytes são copiados: quem chamou pode
+ * transferir os seus); acima disso, só o fim (`RESPONSE_TAIL_BYTES`), lido pelas chaves da raiz.
+ */
+function jsonObserver(call, api) {
+    const chunks = [];
+    let kept = 0;
+    let overflow = false;
+    const shape = new JsonShape();
+    return {
+        chunk(bytes) {
+            shape.push(bytes);
+            chunks.push(bytes.slice());
+            kept += bytes.byteLength;
+            if (!overflow && kept > MAX_RESPONSE_PARSE_BYTES)
+                overflow = true;
+            // Só o fim interessa: descarta do começo mantendo pelo menos `RESPONSE_TAIL_BYTES`.
+            if (overflow)
+                while (chunks.length > 1 && kept - chunks[0].byteLength >= RESPONSE_TAIL_BYTES)
+                    kept -= chunks.shift().byteLength;
+        },
+        end() {
+            const text = new TextDecoder().decode(Buffer.concat(chunks));
+            chunks.length = 0;
+            // Corpo que não é um objeto JSON inteiro (cortado pelo gateway, lixo depois da raiz): a resposta
+            // não serve, e nada dela vira atributo. No fim de um corpo grande, o `}` final só é da raiz se a
+            // estrutura acompanhada desde o primeiro byte o provar.
+            if (!shape.complete)
+                return call.finish('incomplete');
+            if (overflow)
+                return applyTail(call, api, text);
+            const parsed = safeParse(text);
+            if (parsed === undefined || parsed === null || typeof parsed !== 'object' || Array.isArray(parsed))
+                return call.finish('incomplete');
+            applyJson(call, api, obj(parsed));
+        },
+    };
+}
+/**
+ * Estrutura de um corpo JSON acompanhada byte a byte desde o início, sem guardar o corpo: profundidade
+ * de `{`/`[` fora de strings (cada `"` não escapado alterna; `\` escapa o byte seguinte). Os bytes que
+ * importam (`"`, `\`, chaves e colchetes) são ASCII e nunca aparecem dentro de um caractere UTF-8 de
+ * vários bytes, então os pedaços podem ser lidos como chegam, partidos em qualquer ponto.
+ * `complete` = o corpo é um objeto (`{` como primeiro byte não branco) cuja raiz fecha uma vez, no
+ * fim, com no máximo espaço em branco depois.
+ */
+export class JsonShape {
+    depth = 0;
+    inString = false;
+    escaped = false;
+    started = false;
+    closed = false;
+    broken = false;
+    push(bytes) {
+        if (this.broken)
+            return;
+        for (let i = 0; i < bytes.length; i += 1) {
+            const b = bytes[i];
+            if (this.inString) {
+                if (this.escaped)
+                    this.escaped = false;
+                else if (b === 0x5c)
+                    this.escaped = true;
+                else if (b === 0x22)
+                    this.inString = false;
+                continue;
+            }
+            // Espaço, tab, LF, CR: permitidos em qualquer lugar fora de strings, inclusive depois da raiz.
+            if (b === 0x20 || b === 0x09 || b === 0x0a || b === 0x0d)
+                continue;
+            if (this.closed || (!this.started && b !== 0x7b)) {
+                this.broken = true;
+                return;
+            }
+            this.started = true;
+            if (b === 0x22)
+                this.inString = true;
+            else if (b === 0x7b || b === 0x5b)
+                this.depth += 1;
+            else if (b === 0x7d || b === 0x5d) {
+                this.depth -= 1;
+                if (this.depth === 0)
+                    this.closed = true;
+            }
+        }
+    }
+    get complete() {
+        return !this.broken && this.closed && !this.inString;
+    }
+}
+function failStream(call, err) {
+    const name = err?.name;
+    call.errorType = errorTypeOf(err?.cause?.code) ?? errorTypeOf(name) ?? '_OTHER';
+    call.finish('error', err);
+}
+/** Lê a cópia do corpo de erro até `limit` bytes; acima disso para (e cancela a cópia). */
+async function readCopy(call, reader, limit) {
+    const chunks = [];
+    let total = 0;
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        // Corpo ainda chegando: o prazo de `observationIdleMs` conta a partir da última leitura, como no stream.
+        call.markActivity();
+        total += value.byteLength;
+        if (total > limit) {
+            await reader.cancel().catch(() => undefined);
+            break;
+        }
+        chunks.push(value);
+    }
+    return new TextDecoder().decode(Buffer.concat(chunks));
+}
+/**
+ * Cópia do corpo de um erro HTTP sem mudar o que quem chamou pode fazer com o seu: `clone()` divide o
+ * corpo em dois ramos, e o cancelamento de um ramo só chega à conexão quando o outro também cancela.
+ * Por isso a `Response` devolvida tem o corpo original repassado sob demanda, e cancelá-lo cancela
+ * também a cópia depois de no máximo `ERROR_BODY_GRACE_MS` (para ler o código do provedor), ou na
+ * hora se o span já fechou: a conexão fecha como sem instrumentação. Se o span fecha durante a
+ * tolerância, a cópia cancela junto. Sem `clone()` disponível, devolve `null`.
+ */
+function observedCopy(call, res) {
+    let copy;
+    try {
+        copy = res.clone();
+    }
+    catch {
+        return null;
+    }
+    const copyReader = copy.body.getReader();
+    const stopCopy = () => void copyReader.cancel().catch(() => undefined);
+    // O cancelamento da aplicação só chega à conexão quando a cópia também cancela. Ela cancela no fim
+    // da tolerância ou quando o span fecha (código lido, prazo sem leitura, abort), o que vier antes:
+    // o fim do span nunca desarma esse cancelamento. Sem cancelamento da aplicação, a cópia segue
+    // até o fim do corpo ou o limite, presa à conexão que a aplicação ainda mantém.
+    let appCancelled = false;
+    call.onFinish(() => {
+        if (appCancelled)
+            stopCopy();
+    });
+    const wrapped = relayResponse(res, {
+        cancel() {
+            appCancelled = true;
+            if (call.done)
+                return stopCopy();
+            const timer = setTimeout(stopCopy, ERROR_BODY_GRACE_MS);
+            if (typeof timer === 'object' && timer && 'unref' in timer)
+                timer.unref();
+        },
+    });
+    if (!wrapped) {
+        void stopCopy();
+        return null;
+    }
+    return { response: wrapped, copy: copyReader };
+}
+/**
+ * HTTP ≥ 400: o desfecho já é `error` (nem o prazo sem leitura, nem abort, nem cancelar o corpo o
+ * trocam); `error.type` = código do provedor no corpo, ou o status. 5xx já vem com `span.error` do
+ * `fetch`. O corpo é lido numa cópia limitada a `MAX_ERROR_BODY_BYTES` (os clientes OpenAI/Anthropic
+ * cancelam o corpo sem lê-lo antes de tentar de novo), então o que a cópia adianta da conexão também
+ * fica nesse limite.
+ */
+function observeError(call, res) {
+    call.errorType = String(res.status);
+    call.failed = true;
+    const observed = isWebResponse(res) ? observedCopy(call, res) : null;
+    if (!observed) {
+        call.finish('error');
+        return res;
+    }
+    call.armWatchdog();
+    readCopy(call, observed.copy, MAX_ERROR_BODY_BYTES).then((text) => guard(call, () => {
+        const body = obj(safeParse(text));
+        const error = obj(body.error);
+        const type = errorTypeOf(error.code) ?? errorTypeOf(error.type);
+        if (type)
+            call.errorType = type;
+        call.finish('error');
+    }), () => guard(call, () => call.finish('error')));
+    return observed.response;
+}
+/**
+ * Observa a resposta e devolve a que vai para quem chamou: uma equivalente cujo corpo é repassado
+ * sob demanda e observado no caminho (JSON e stream SSE, sem leitura adiantada; erro HTTP numa cópia
+ * limitada), ou a própria quando não dá para observar. O span fecha quando a observação termina.
+ */
+export function observeHttpGenAiResponse(call, res, api, signal) {
+    try {
+        if (signal?.aborted === true) {
+            // Abortado entre os headers e a devolução da `Response` (um `fetch` intermediário que ainda fez
+            // algo depois dos headers): o corpo vai rejeitar, e quem chamou desistiu. Num 4xx/5xx o status
+            // já decidiu (`failed` mantém `error`).
+            if (res.status >= 400) {
+                call.errorType = String(res.status);
+                call.failed = true;
+            }
+            call.finish('cancelled');
+            return res;
+        }
+        if (signal && typeof signal.addEventListener === 'function') {
+            const onAbort = () => guard(call, () => call.finish('cancelled'));
+            signal.addEventListener('abort', onAbort, { once: true });
+            call.onFinish(() => signal.removeEventListener('abort', onAbort));
+        }
+        if (res.status >= 400)
+            return observeError(call, res);
+        if (!res.body) {
+            call.finish('completed');
+            return res;
+        }
+        if (!isWebResponse(res)) {
+            call.finish('unobserved');
+            return res;
+        }
+        const type = (res.headers.get('content-type') ?? '').toLowerCase();
+        const observer = type.includes('text/event-stream')
+            ? sseObserver(call, call.operation === 'chat' && api === 'anthropic' ? anthropicStream(call) : openAiStream(call))
+            : jsonObserver(call, api);
+        call.armWatchdog();
+        return observeBody(call, res, observer, signal);
+    }
+    catch {
+        call.finish('unobserved');
+        return res;
+    }
+}
+//# sourceMappingURL=http.js.map