@hebo-ai/gateway 0.4.0-beta.3 → 0.4.0

package/src/telemetry/span.ts

@@ -1,28 +1,13 @@
-import type { Attributes, Span, SpanOptions, Tracer } from "@opentelemetry/api";
+import type { Attributes, SpanOptions, Tracer } from "@opentelemetry/api";
 
 import { INVALID_SPAN_CONTEXT, SpanKind, SpanStatusCode, context, trace } from "@opentelemetry/api";
 
-const DEFAULT_TRACER_NAME = "@hebo-ai/gateway";
-const mem = () => process?.memoryUsage?.();
+import type { TelemetrySignalLevel } from "../types";
 
-const toError = (error: unknown) => (error instanceof Error ? error : new Error(String(error)));
+const DEFAULT_TRACER_NAME = "@hebo/gateway";
 
-const maybeSetDynamicAttributes = (span: Span, getAttributes: () => Attributes) => {
-  const attrs = getAttributes();
-  if (Object.keys(attrs).length === 0) return;
-  span.setAttributes(attrs);
-};
-
-const getMemoryAttributes = (): Attributes => {
-  const memory = mem();
-  if (!memory) return {};
-
-  return {
-    "process.memory.usage": memory.rss,
-    "process.memory.heap.used": memory.heapUsed,
-    "process.memory.heap.total": memory.heapTotal,
-  };
-};
+let spanTracer: Tracer | undefined;
+let spanEventsEnabled = false;
 
 const NOOP_SPAN = {
   runWithContext: <T>(fn: () => Promise<T> | T) => fn(),
@@ -31,35 +16,38 @@ const NOOP_SPAN = {
   isExisting: true,
 };
 
-export const startSpan = (name: string, options?: SpanOptions, customTracer?: Tracer) => {
-  const tracer = customTracer ?? trace.getTracer(DEFAULT_TRACER_NAME);
+export const setSpanTracer = (tracer?: Tracer) => {
+  spanTracer = tracer ?? trace.getTracer(DEFAULT_TRACER_NAME);
+};
+
+export const setSpanEventsEnabled = (level?: TelemetrySignalLevel) => {
+  spanEventsEnabled = level === "recommended" || level === "full";
+};
+
+export const startSpan = (name: string, options?: SpanOptions) => {
+  if (!spanTracer) {
+    return Object.assign(trace.wrapSpanContext(INVALID_SPAN_CONTEXT), NOOP_SPAN);
+  }
 
   const parentContext = context.active();
   const activeSpan = trace.getActiveSpan();
 
-  const span = tracer.startSpan(
+  const span = spanTracer.startSpan(
     name,
     { kind: activeSpan ? SpanKind.INTERNAL : SpanKind.SERVER, ...options },
     parentContext,
   );
 
-  if (!span.isRecording()) {
-    return Object.assign(trace.wrapSpanContext(INVALID_SPAN_CONTEXT), NOOP_SPAN);
-  }
-
-  maybeSetDynamicAttributes(span, getMemoryAttributes);
-
   const runWithContext = <T>(fn: () => Promise<T> | T) =>
     context.with(trace.setSpan(parentContext, span), fn);
 
   const recordError = (error: unknown) => {
-    const err = toError(error);
+    const err = error instanceof Error ? error : new Error(String(error));
     span.recordException(err);
     span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
   };
 
   const finish = () => {
-    maybeSetDynamicAttributes(span, getMemoryAttributes);
     span.end();
   };
 
@@ -71,6 +59,10 @@ export const withSpan = async <T>(
   run: () => Promise<T> | T,
   options?: SpanOptions,
 ): Promise<T> => {
+  if (!spanTracer) {
+    return await run();
+  }
+
   const started = startSpan(name, options);
   try {
     return await started.runWithContext(run);
@@ -83,15 +75,11 @@ export const withSpan = async <T>(
 };
 
 export const addSpanEvent = (name: string, attributes?: Attributes) => {
-  const allAttributes = Object.assign(attributes ?? {}, getMemoryAttributes());
-  trace.getActiveSpan()?.addEvent(name, allAttributes);
+  if (!spanEventsEnabled) return;
+  trace.getActiveSpan()?.addEvent(name, attributes);
 };
 
-export const recordSpanError = (error: unknown) => {
-  const span = trace.getActiveSpan();
-  if (!span) return;
-
-  const err = toError(error);
-  span.recordException(err);
-  span.setStatus({ code: SpanStatusCode.ERROR, message: err.message });
+export const setSpanAttributes = (attributes?: Attributes) => {
+  if (!attributes) return;
+  trace.getActiveSpan()?.setAttributes(attributes);
 };

package/src/telemetry/stream.ts

@@ -1,58 +1,51 @@
-export type InstrumentStreamHooks = {
-  onComplete?: (status: number, stats: { bytes: number }) => void;
-  onError?: (error: unknown, status: number) => void;
-};
-
-export const instrumentStream = (
-  src: ReadableStream<Uint8Array>,
-  hooks: InstrumentStreamHooks,
-  signal?: AbortSignal,
-): ReadableStream<Uint8Array> => {
-  const stats = { bytes: 0 };
-  let done = false;
+import { toOpenAIError } from "#/errors/openai";
 
-  const finish = (status: number, reason?: unknown) => {
-    if (done) return;
-    done = true;
+const isErrorChunk = (v: unknown) => v instanceof Error || !!(v as any)?.error;
 
-    if (!reason) reason = signal?.reason;
+export const wrapStream = (
+  src: ReadableStream,
+  hooks: { onDone?: (status: number, reason: unknown) => void },
+): ReadableStream => {
+  let finished = false;
 
-    if (status >= 400) {
-      hooks.onError?.(reason, status);
+  const done = (
+    reader: ReadableStreamDefaultReader,
+    controller: ReadableStreamDefaultController,
+    status: number,
+    reason?: unknown,
+  ) => {
+    if (!finished) {
+      finished = true;
+      hooks.onDone?.(status, reason);
     }
-
-    hooks.onComplete?.(status, stats);
+    reader.cancel(reason).catch(() => {});
+    controller.close();
   };
 
-  return new ReadableStream<Uint8Array>({
+  return new ReadableStream({
     async start(controller) {
       const reader = src.getReader();
 
       try {
         for (;;) {
-          if (signal?.aborted) {
-            finish(499, signal.reason);
-            reader.cancel(signal.reason).catch(() => {});
-            controller.close();
-            return;
-          }
-
           // eslint-disable-next-line no-await-in-loop
-          const { value, done } = await reader.read();
-          if (done) break;
+          const { value, done: eof } = await reader.read();
+          if (eof) break;
 
-          stats.bytes += value!.byteLength;
-          controller.enqueue(value!);
+          const out = isErrorChunk(value) ? toOpenAIError(value) : value;
+          controller.enqueue(out);
+
+          if (out !== value) {
+            const status = out.error?.type === "invalid_request_error" ? 422 : 502;
+            done(reader, controller, status, value);
+            return;
+          }
         }
 
-        finish(200);
-        controller.close();
+        done(reader, controller, 200);
       } catch (err) {
-        const status = signal?.aborted ? 499 : (err as any)?.name === "AbortError" ? 503 : 502;
-
-        finish(status, err);
-        reader.cancel(err).catch(() => {});
-        controller.close();
+        controller.enqueue(toOpenAIError(err));
+        done(reader, controller, 502, err);
       } finally {
         try {
           reader.releaseLock();
@@ -61,7 +54,10 @@ export const instrumentStream = (
     },
 
     cancel(reason) {
-      finish(499, reason);
+      if (!finished) {
+        finished = true;
+        hooks.onDone?.(499, reason);
+      }
       src.cancel(reason).catch(() => {});
     },
   });

package/src/types.ts

@@ -8,7 +8,6 @@ import type {
 } from "./endpoints/chat-completions/schema";
 import type { Embeddings, EmbeddingsBody } from "./endpoints/embeddings/schema";
 import type { Model, ModelList } from "./endpoints/models";
-import type { OpenAIError } from "./errors/openai";
 import type { Logger, LoggerConfig } from "./logger";
 import type { ModelCatalog, ModelId } from "./models/types";
 import type { ProviderId, ProviderRegistry } from "./providers/types";
@@ -76,7 +75,7 @@ export type GatewayContext = {
    */
   result?:
     | ChatCompletions
-    | ReadableStream<ChatCompletionsChunk | OpenAIError>
+    | ReadableStream<ChatCompletionsChunk | Error>
     | Embeddings
     | Model
     | ModelList;
@@ -84,10 +83,6 @@ export type GatewayContext = {
    * Response object returned by the handler.
    */
   response?: Response;
-  /**
-   * Structured object result for streaming requests. Only available at the end of the stream.
-   */
-  streamResult?: ChatCompletions;
 };
 
 /**
@@ -154,11 +149,9 @@ export type GatewayHooks = {
   ) =>
     | void
     | ChatCompletions
-    | ReadableStream<ChatCompletionsChunk | OpenAIError>
+    | ReadableStream<ChatCompletionsChunk | Error>
     | Embeddings
-    | Promise<
-        void | ChatCompletions | ReadableStream<ChatCompletionsChunk | OpenAIError> | Embeddings
-      >;
+    | Promise<void | ChatCompletions | ReadableStream<ChatCompletionsChunk | Error> | Embeddings>;
   /**
    * Runs after the lifecycle has produced the final Response.
    * @returns Replacement Response, or undefined to keep original.
@@ -166,6 +159,8 @@ export type GatewayHooks = {
   onResponse?: (ctx: OnResponseHookContext) => void | Response | Promise<void | Response>;
 };
 
+export type TelemetrySignalLevel = "off" | "required" | "recommended" | "full";
+
 /**
  * Main configuration object for the gateway.
  */
@@ -186,6 +181,10 @@ export type GatewayConfig = {
    * Optional lifecycle hooks for routing, auth, and response shaping.
    */
   hooks?: GatewayHooks;
+  /**
+   * Preferred logger configuration: custom logger or default logger settings.
+   */
+  logger?: Logger | LoggerConfig | null;
   /**
    * Optional AI SDK telemetry configuration.
    */
@@ -200,17 +199,18 @@ export type GatewayConfig = {
      */
     tracer?: Tracer;
     /**
-     * Controls how many telemetry attributes are attached to spans.
-     * - required: minimal safe baseline
+     * Telemetry signal levels by namespace.
+     * - off: disable the namespace
+     * - required: minimal baseline
      * - recommended: practical defaults
-     * - full: include all available attributes
+     * - full: include all available details
      */
-    attributes?: "required" | "recommended" | "full";
+    signals?: {
+      gen_ai?: TelemetrySignalLevel;
+      http?: TelemetrySignalLevel;
+      hebo?: TelemetrySignalLevel;
+    };
   };
-  /**
-   * Preferred logger configuration: custom logger or default logger settings.
-   */
-  logger?: Logger | LoggerConfig | null;
 };
 
 export const kParsed = Symbol("hebo.gateway.parsed");

package/src/utils/headers.ts

@@ -1,32 +1,21 @@
 export const REQUEST_ID_HEADER = "x-request-id";
 
-type HeaderSource =
-  | string
-  | URL
-  | Headers
-  | Request
-  | Response
-  | RequestInit
-  | ResponseInit
-  | HeadersInit
-  | undefined;
+type HeaderSource = Request | ResponseInit | undefined;
 
 export const resolveRequestId = (source: HeaderSource): string | undefined => {
-  if (!source || typeof source === "string" || source instanceof URL) return undefined;
+  if (!source) return undefined;
 
-  if (source instanceof Request || source instanceof Response) {
+  if (source instanceof Request) {
     return source.headers.get(REQUEST_ID_HEADER) ?? undefined;
   }
 
-  const headers = "headers" in source ? source.headers : source;
-  if (!headers || typeof headers === "string") return undefined;
+  const headers = source.headers;
+  if (!headers) return undefined;
 
-  if (Object.getPrototypeOf(headers) === Object.prototype) {
-    return (headers as Record<string, string>)[REQUEST_ID_HEADER] ?? undefined;
+  if (headers instanceof Headers) {
+    return headers.get(REQUEST_ID_HEADER) ?? undefined;
   }
 
-  if (headers instanceof Headers) return headers.get(REQUEST_ID_HEADER) ?? undefined;
-
   if (Array.isArray(headers)) {
     for (const [key, value] of headers) {
       if (key.toLowerCase() === REQUEST_ID_HEADER) return value;
@@ -34,5 +23,5 @@ export const resolveRequestId = (source: HeaderSource): string | undefined => {
     return undefined;
   }
 
-  return undefined;
+  return headers[REQUEST_ID_HEADER];
 };

package/src/utils/request.ts

@@ -18,17 +18,6 @@ export const prepareRequestHeaders = (request: Request) => {
   return headers;
 };
 
-export const prepareRequestBody = async (request: Request) => {
-  let requestBytes = 0;
-  let body: ArrayBuffer | undefined;
-  if (request.body) {
-    body = await request.arrayBuffer();
-    requestBytes = body.byteLength;
-  }
-
-  return { body, requestBytes };
-};
-
 export const prepareForwardHeaders = (request: Request): Record<string, string> => {
   const userAgent = request.headers.get("user-agent");
   const appendedUserAgent = userAgent

package/src/utils/response.ts

@@ -16,7 +16,7 @@ class JsonToSseTransformStream extends TransformStream<unknown, string> {
 }
 
 export const prepareResponseInit = (request: Request): ResponseInit => ({
-  headers: { [REQUEST_ID_HEADER]: resolveRequestId(request.headers)! },
+  headers: { [REQUEST_ID_HEADER]: resolveRequestId(request)! },
 });
 
 export const mergeResponseInit = (

package/dist/telemetry/otel.d.ts

@@ -1,2 +0,0 @@
-import type { GatewayConfigParsed, GatewayContext } from "../types";
-export declare const withOtel: (run: (ctx: GatewayContext) => Promise<void>, config: GatewayConfigParsed) => (ctx: GatewayContext) => Promise<void>;

package/dist/telemetry/otel.js

@@ -1,50 +0,0 @@
-import { SpanStatusCode } from "@opentelemetry/api";
-import { initFetch } from "./fetch";
-import { startSpan } from "./span";
-import { instrumentStream } from "./stream";
-import { getAIAttributes, getBaggageAttributes, getRequestAttributes, getResponseAttributes, } from "./utils";
-export const withOtel = (run, config) => async (ctx) => {
-    const requestStart = performance.now();
-    const aiSpan = startSpan(ctx.request.url, undefined, config.telemetry?.tracer);
-    initFetch();
-    const endAiSpan = (status, stats) => {
-        const attrs = getAIAttributes(ctx.body, ctx.streamResult ?? ctx.result, config.telemetry?.attributes, ctx.resolvedProviderId);
-        attrs["gen_ai.server.request.duration"] = Number(((performance.now() - requestStart) / 1000).toFixed(4));
-        if (!aiSpan.isExisting) {
-            Object.assign(attrs, getRequestAttributes(ctx.request, config.telemetry?.attributes), getResponseAttributes(ctx.response, config.telemetry?.attributes));
-        }
-        Object.assign(attrs, getBaggageAttributes(ctx.request));
-        if (config.telemetry?.attributes !== "required") {
-            attrs["http.request.body.size"] = Number(ctx.request.headers.get("content-length") || 0);
-            attrs["http.response.body.size"] =
-                stats?.bytes ?? Number(attrs["http.response.header.content-length"] || 0);
-        }
-        if (config.telemetry?.attributes === "full") {
-            attrs["http.request.body"] = JSON.stringify(ctx.body);
-        }
-        const realStatus = status === 200 ? (ctx.response?.status ?? status) : status;
-        attrs["http.response.status_code_effective"] = realStatus;
-        aiSpan.setStatus({ code: realStatus >= 500 ? SpanStatusCode.ERROR : SpanStatusCode.OK });
-        if (ctx.operation && ctx.modelId) {
-            aiSpan.updateName(`${ctx.operation} ${ctx.modelId}`);
-        }
-        else if (ctx.operation) {
-            aiSpan.updateName(`${ctx.operation}`);
-        }
-        aiSpan.setAttributes(attrs);
-        aiSpan.finish();
-    };
-    await aiSpan.runWithContext(() => run(ctx));
-    if (ctx.response.body instanceof ReadableStream) {
-        const instrumented = instrumentStream(ctx.response.body, {
-            onComplete: (status, params) => endAiSpan(status, params),
-        }, ctx.request.signal);
-        ctx.response = new Response(instrumented, {
-            status: ctx.response.status,
-            statusText: ctx.response.statusText,
-            headers: ctx.response.headers,
-        });
-        return;
-    }
-    endAiSpan(ctx.response.status);
-};

package/dist/telemetry/utils.d.ts

@@ -1,4 +0,0 @@
-export declare const getRequestAttributes: (request?: Request, attributesLevel?: string) => {};
-export declare const getAIAttributes: (body?: object, result?: object, attributesLevel?: string, providerName?: string) => {};
-export declare const getResponseAttributes: (response?: Response, attributesLevel?: string) => {};
-export declare const getBaggageAttributes: (request?: Request) => Record<string, string>;

package/dist/telemetry/utils.js

@@ -1,223 +0,0 @@
-import { resolveRequestId } from "../utils/headers";
-const DEFAULT_ATTRIBUTES_LEVEL = "recommended";
-const HEBO_BAGGAGE_PREFIX = "hebo.";
-const toTextPart = (content) => ({ type: "text", content });
-const toMessageParts = (message) => {
-    if (message.role === "assistant") {
-        const parts = [];
-        if (typeof message.content === "string")
-            parts.push(toTextPart(message.content));
-        if (Array.isArray(message.tool_calls)) {
-            for (const call of message.tool_calls) {
-                parts.push({
-                    type: "tool_call",
-                    id: call.id,
-                    name: call.function.name,
-                    arguments: call.function.arguments,
-                });
-            }
-        }
-        return parts;
-    }
-    if (message.role === "tool") {
-        return [{ type: "tool_call_response", id: message.tool_call_id, content: message.content }];
-    }
-    if (message.role === "user") {
-        const parts = [];
-        if (typeof message.content === "string")
-            parts.push(toTextPart(message.content));
-        if (Array.isArray(message.content)) {
-            for (const part of message.content) {
-                if (part.type === "text") {
-                    parts.push(toTextPart(part.text));
-                }
-                else if (part.type === "image_url") {
-                    parts.push({ type: "image", content: part.image_url.url });
-                }
-                else {
-                    parts.push({
-                        type: "file",
-                        // FUTURE: optionally expose safe metadata without raw binary payloads.
-                        content: part.file.filename ?? "[REDACTED_BINARY_DATA]",
-                        media_type: part.file.media_type,
-                    });
-                }
-            }
-        }
-        return parts;
-    }
-    return [];
-};
-export const getRequestAttributes = (request, attributesLevel = DEFAULT_ATTRIBUTES_LEVEL) => {
-    if (!request)
-        return {};
-    let url;
-    try {
-        // FUTURE: use URL from lifecycle
-        url = new URL(request.url);
-    }
-    catch { }
-    const attrs = {
-        "http.request.method": request.method,
-        "url.full": request.url,
-        "url.path": url?.pathname,
-        "url.scheme": url?.protocol.replace(":", ""),
-        "server.address": url?.hostname,
-        "server.port": url
-            ? url.port
-                ? Number(url.port)
-                : url.protocol === "https:"
-                    ? 443
-                    : 80
-            : undefined,
-    };
-    if (attributesLevel !== "required") {
-        Object.assign(attrs, {
-            "http.request.id": resolveRequestId(request),
-            "user_agent.original": request.headers.get("user-agent") ?? undefined,
-        });
-    }
-    if (attributesLevel === "full") {
-        Object.assign(attrs, {
-            // FUTURE: "url.query"
-            "http.request.header.content-type": [request.headers.get("content-type") ?? undefined],
-            "http.request.header.content-length": [request.headers.get("content-length") ?? undefined],
-            // FUTURE: "client.address"
-        });
-    }
-    return attrs;
-};
-export const getAIAttributes = (body, result, attributesLevel = DEFAULT_ATTRIBUTES_LEVEL, providerName) => {
-    if (!body && !result)
-        return {};
-    const isChat = !!body && "messages" in body;
-    const isEmbeddings = !!body && "input" in body;
-    const attrs = {
-        "gen_ai.operation.name": isEmbeddings ? "embeddings" : isChat ? "chat" : undefined,
-        "gen_ai.output.type": isEmbeddings ? "embedding" : isChat ? "text" : undefined,
-        "gen_ai.request.model": body && "model" in body ? body.model : undefined,
-        "gen_ai.provider.name": providerName,
-    };
-    if (isChat) {
-        if (body) {
-            const inputs = body;
-            if (inputs.seed !== undefined) {
-                Object.assign(attrs, { "gen_ai.request.seed": inputs.seed });
-            }
-            if (attributesLevel !== "required") {
-                Object.assign(attrs, {
-                    "gen_ai.request.stream": inputs.stream,
-                    "gen_ai.request.frequency_penalty": inputs.frequency_penalty,
-                    "gen_ai.request.max_tokens": inputs.max_completion_tokens,
-                    "gen_ai.request.presence_penalty": inputs.presence_penalty,
-                    "gen_ai.request.stop_sequences": inputs.stop
-                        ? Array.isArray(inputs.stop)
-                            ? inputs.stop
-                            : [inputs.stop]
-                        : undefined,
-                    "gen_ai.request.temperature": inputs.temperature,
-                    "gen_ai.request.top_p": inputs.top_p,
-                });
-            }
-            if (attributesLevel === "full") {
-                Object.assign(attrs, {
-                    // FUTURE: only construct once
-                    "gen_ai.system_instructions": inputs.messages
-                        .filter((m) => m.role === "system")
-                        .map((m) => JSON.stringify({ parts: [toTextPart(m.content)] })),
-                    "gen_ai.input.messages": inputs.messages
-                        .filter((m) => m.role !== "system")
-                        .map((m) => JSON.stringify({ role: m.role, parts: toMessageParts(m) })),
-                    "gen_ai.tool.definitions": JSON.stringify(inputs.tools),
-                });
-            }
-        }
-        // FUTURE: implement streaming
-        if (result && !(result instanceof ReadableStream)) {
-            const completions = result;
-            Object.assign(attrs, {
-                "gen_ai.response.model": completions.model,
-                "gen_ai.response.id": completions.id,
-            });
-            if (attributesLevel !== "required") {
-                Object.assign(attrs, {
-                    "gen_ai.response.finish_reasons": completions.choices?.map((c) => c.finish_reason),
-                    "gen_ai.usage.total_tokens": completions.usage?.total_tokens,
-                    "gen_ai.usage.input_tokens": completions.usage?.prompt_tokens,
-                    "gen_ai.usage.cached_tokens": completions.usage?.prompt_tokens_details?.cached_tokens,
-                    "gen_ai.usage.output_tokens": completions.usage?.completion_tokens,
-                    "gen_ai.usage.reasoning_tokens": completions.usage?.completion_tokens_details?.reasoning_tokens,
-                });
-            }
-            if (attributesLevel === "full") {
-                Object.assign(attrs, {
-                    "gen_ai.output.messages": completions.choices?.map((c) => JSON.stringify({
-                        role: c.message.role,
-                        parts: toMessageParts(c.message),
-                        finish_reason: c.finish_reason,
-                    })),
-                });
-            }
-        }
-    }
-    if (isEmbeddings) {
-        if (body) {
-            const inputs = body;
-            if (attributesLevel !== "required") {
-                Object.assign(attrs, {
-                    "gen_ai.embeddings.dimension.count": inputs.dimensions,
-                });
-            }
-        }
-        if (result) {
-            const embeddings = result;
-            Object.assign(attrs, {
-                "gen_ai.response.model": embeddings.model,
-            });
-            if (attributesLevel !== "required") {
-                Object.assign(attrs, {
-                    "gen_ai.usage.input_tokens": embeddings.usage?.prompt_tokens,
-                    "gen_ai.usage.total_tokens": embeddings.usage?.total_tokens,
-                });
-            }
-        }
-    }
-    return attrs;
-};
-export const getResponseAttributes = (response, attributesLevel = DEFAULT_ATTRIBUTES_LEVEL) => {
-    if (!response)
-        return {};
-    const attrs = {
-        "http.response.status_code": response.status,
-    };
-    if (attributesLevel === "full") {
-        Object.assign(attrs, {
-            "http.response.header.content-type": [response.headers.get("content-type") ?? undefined],
-            "http.response.header.content-length": [response.headers.get("content-length") ?? undefined],
-        });
-    }
-    return attrs;
-};
-export const getBaggageAttributes = (request) => {
-    const h = request?.headers.get("baggage");
-    if (!h)
-        return {};
-    const attrs = {};
-    for (const part of h.split(",")) {
-        const [k, v] = part.trim().split("=", 2);
-        if (!k || !v)
-            continue;
-        const [rawValue] = v.split(";", 1);
-        if (!rawValue)
-            continue;
-        let value = rawValue;
-        try {
-            value = decodeURIComponent(rawValue);
-        }
-        catch { }
-        if (k.startsWith(HEBO_BAGGAGE_PREFIX)) {
-            attrs[k.slice(HEBO_BAGGAGE_PREFIX.length)] = value;
-        }
-    }
-    return attrs;
-};