@hebo-ai/gateway 0.10.5 → 0.10.7

package/dist/endpoints/chat-completions/handler.js

@@ -133,6 +133,8 @@ export const chatCompletions = (config) => {
         });
         logger.trace({ requestId: ctx.requestId, result }, "[chat] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
+        if (result.response.headers)
+            ctx.response = { headers: result.response.headers };
         recordTimeToFirstToken(performance.now() - start, genAiGeneralAttrs, ctx.trace);
         // Transform result.
         ctx.result = toChatCompletions(result, ctx.resolvedModelId);

package/dist/endpoints/chat-completions/schema.d.ts

@@ -1055,8 +1055,8 @@ export declare const ChatCompletionsBodySchema: z.ZodObject<{
 export type ChatCompletionsBody = z.infer<typeof ChatCompletionsBodySchema>;
 export declare const ChatCompletionsFinishReasonSchema: z.ZodEnum<{
     length: "length";
-    stop: "stop";
     tool_calls: "tool_calls";
+    stop: "stop";
     content_filter: "content_filter";
 }>;
 export type ChatCompletionsFinishReason = z.infer<typeof ChatCompletionsFinishReasonSchema>;
@@ -1109,8 +1109,8 @@ export declare const ChatCompletionsChoiceSchema: z.ZodObject<{
     }, z.core.$strip>;
     finish_reason: z.ZodEnum<{
         length: "length";
-        stop: "stop";
         tool_calls: "tool_calls";
+        stop: "stop";
         content_filter: "content_filter";
     }>;
     logprobs: z.ZodOptional<z.ZodUnknown>;
@@ -1183,8 +1183,8 @@ export declare const ChatCompletionsSchema: z.ZodObject<{
         }, z.core.$strip>;
         finish_reason: z.ZodEnum<{
             length: "length";
-            stop: "stop";
             tool_calls: "tool_calls";
+            stop: "stop";
             content_filter: "content_filter";
         }>;
         logprobs: z.ZodOptional<z.ZodUnknown>;
@@ -1319,8 +1319,8 @@ export declare const ChatCompletionsChoiceDeltaSchema: z.ZodObject<{
     }, z.core.$strip>;
     finish_reason: z.ZodNullable<z.ZodEnum<{
         length: "length";
-        stop: "stop";
         tool_calls: "tool_calls";
+        stop: "stop";
         content_filter: "content_filter";
     }>>;
     logprobs: z.ZodOptional<z.ZodUnknown>;
@@ -1381,8 +1381,8 @@ export declare const ChatCompletionsChunkSchema: z.ZodObject<{
         }, z.core.$strip>;
         finish_reason: z.ZodNullable<z.ZodEnum<{
             length: "length";
-            stop: "stop";
             tool_calls: "tool_calls";
+            stop: "stop";
             content_filter: "content_filter";
         }>>;
         logprobs: z.ZodOptional<z.ZodUnknown>;

package/dist/endpoints/embeddings/handler.js

@@ -81,6 +81,8 @@ export const embeddings = (config) => {
         });
         logger.trace({ requestId: ctx.requestId, result }, "[embeddings] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
+        if (result.responses?.[0]?.headers)
+            ctx.response = { headers: result.responses[0].headers };
         // Transform result.
         ctx.result = toEmbeddings(result, ctx.modelId);
         logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[chat] Embeddings");

package/dist/endpoints/messages/handler.js

@@ -124,6 +124,8 @@ export const messages = (config) => {
         });
         logger.trace({ requestId: ctx.requestId, result }, "[messages] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
+        if (result.response.headers)
+            ctx.response = { headers: result.response.headers };
         recordTimeToFirstToken(performance.now() - start, genAiGeneralAttrs, ctx.trace);
         ctx.result = toMessages(result, ctx.resolvedModelId);
         logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[messages] Messages");

package/dist/endpoints/responses/handler.js

@@ -123,6 +123,8 @@ export const responses = (config) => {
         });
         logger.trace({ requestId: ctx.requestId, result }, "[responses] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
+        if (result.response.headers)
+            ctx.response = { headers: result.response.headers };
         recordTimeToFirstToken(performance.now() - start, genAiGeneralAttrs, ctx.trace);
         ctx.result = toResponses(result, ctx.resolvedModelId, ctx.body.metadata);
         logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[responses] Responses");

package/dist/errors/ai-sdk.js

@@ -1,11 +1,20 @@
 import { AISDKError, APICallError, DownloadError, EmptyResponseBodyError, InvalidArgumentError, InvalidDataContentError, InvalidMessageRoleError, InvalidPromptError, InvalidResponseDataError, InvalidStreamPartError, InvalidToolApprovalError, InvalidToolInputError, JSONParseError, LoadAPIKeyError, LoadSettingError, MessageConversionError, MissingToolResultsError, NoContentGeneratedError, NoImageGeneratedError, NoObjectGeneratedError, NoOutputGeneratedError, NoSpeechGeneratedError, NoSuchModelError, NoSuchProviderError, NoSuchToolError, NoTranscriptGeneratedError, NoVideoGeneratedError, RetryError, ToolCallNotFoundForApprovalError, ToolCallRepairError, TooManyEmbeddingValuesForCallError, TypeValidationError, UIMessageStreamError, UnsupportedModelVersionError, UnsupportedFunctionalityError, } from "ai";
 import { GatewayError } from "./gateway";
-import { STATUS_CODE } from "./utils";
+import { STATUS_TEXT } from "./utils";
+const normalizeApiCallError = (error) => {
+    const status = error.statusCode ?? (error.isRetryable ? 502 : 422);
+    const statusText = `UPSTREAM_${STATUS_TEXT(status)}`;
+    return new GatewayError(error, status, statusText, undefined, error.responseHeaders ?? undefined);
+};
 export const normalizeAiSdkError = (error) => {
     if (APICallError.isInstance(error)) {
-        const status = error.statusCode ?? (error.isRetryable ? 502 : 422);
-        const code = `UPSTREAM_${STATUS_CODE(status)}`;
-        return new GatewayError(error, status, code);
+        return normalizeApiCallError(error);
+    }
+    if (RetryError.isInstance(error)) {
+        if (APICallError.isInstance(error.lastError)) {
+            return normalizeApiCallError(error.lastError);
+        }
+        return new GatewayError(error, 502, `UPSTREAM_${STATUS_TEXT(502)}`);
     }
     if (JSONParseError.isInstance(error) ||
         InvalidResponseDataError.isInstance(error) ||
@@ -15,7 +24,6 @@ export const normalizeAiSdkError = (error) => {
         NoOutputGeneratedError.isInstance(error) ||
         InvalidStreamPartError.isInstance(error) ||
         UIMessageStreamError.isInstance(error) ||
-        RetryError.isInstance(error) ||
         DownloadError.isInstance(error) ||
         ToolCallRepairError.isInstance(error) ||
         NoImageGeneratedError.isInstance(error) ||
@@ -23,7 +31,7 @@ export const normalizeAiSdkError = (error) => {
         NoSpeechGeneratedError.isInstance(error) ||
         NoTranscriptGeneratedError.isInstance(error) ||
         NoVideoGeneratedError.isInstance(error)) {
-        return new GatewayError(error, 502, `UPSTREAM_${STATUS_CODE(502)}`);
+        return new GatewayError(error, 502, `UPSTREAM_${STATUS_TEXT(502)}`);
     }
     if (InvalidArgumentError.isInstance(error) ||
         InvalidPromptError.isInstance(error) ||
@@ -40,7 +48,7 @@ export const normalizeAiSdkError = (error) => {
         TooManyEmbeddingValuesForCallError.isInstance(error) ||
         NoSuchModelError.isInstance(error) ||
         NoSuchProviderError.isInstance(error)) {
-        return new GatewayError(error, 422, `UPSTREAM_${STATUS_CODE(422)}`);
+        return new GatewayError(error, 422, `UPSTREAM_${STATUS_TEXT(422)}`);
     }
     if (LoadSettingError.isInstance(error) || LoadAPIKeyError.isInstance(error)) {
         return new GatewayError(error, 500);

package/dist/errors/anthropic.d.ts

@@ -9,7 +9,8 @@ export declare const AnthropicErrorSchema: z.ZodObject<{
 export declare class AnthropicError {
     readonly type: "error";
     readonly error: z.infer<typeof AnthropicErrorSchema>["error"];
+    status: number;
     constructor(message: string, type?: string);
 }
-export declare function toAnthropicError(error: unknown): AnthropicError;
-export declare function toAnthropicErrorResponse(error: unknown, responseInit?: ResponseInit): Response;
+export declare function toAnthropicError(error: unknown, requestId?: string): AnthropicError;
+export declare function toAnthropicErrorResponse(error: unknown, init: ResponseInit): Response;

package/dist/errors/anthropic.js

@@ -14,6 +14,8 @@ export class AnthropicError {
     error;
     constructor(message, type = "api_error") {
         this.error = { type, message };
+        // internal property to derive status from error handlers without breaking official format
+        Object.defineProperty(this, "status", { value: 500, writable: true });
     }
 }
 const mapType = (status) => {
@@ -22,12 +24,12 @@ const mapType = (status) => {
             return "invalid_request_error";
         case 401:
             return "authentication_error";
+        case 402:
+            return "billing_error";
         case 403:
             return "permission_error";
         case 404:
             return "not_found_error";
-        case 402:
-            return "billing_error";
         case 413:
             return "request_too_large";
         case 429:
@@ -40,15 +42,12 @@ const mapType = (status) => {
             return status >= 500 ? "api_error" : "invalid_request_error";
     }
 };
-export function toAnthropicError(error) {
+export function toAnthropicError(error, requestId) {
     const meta = getErrorMeta(error);
-    return new AnthropicError(maybeMaskMessage(meta), mapType(meta.status));
+    const anthropicError = new AnthropicError(maybeMaskMessage(error instanceof Error ? error.message : String(error), meta.status, requestId), mapType(meta.status));
+    anthropicError.status = meta.status;
+    return anthropicError;
 }
-export function toAnthropicErrorResponse(error, responseInit) {
-    const meta = getErrorMeta(error);
-    return toResponse(new AnthropicError(maybeMaskMessage(meta, resolveRequestId(responseInit)), mapType(meta.status)), {
-        status: meta.status,
-        statusText: meta.code,
-        headers: responseInit?.headers,
-    });
+export function toAnthropicErrorResponse(error, init) {
+    return toResponse(new AnthropicError(maybeMaskMessage(error instanceof Error ? error.message : String(error), init.status ?? 500, resolveRequestId(init)), mapType(init.status ?? 500)), init);
 }

package/dist/errors/gateway.d.ts

@@ -1,5 +1,6 @@
 export declare class GatewayError extends Error {
     readonly status: number;
-    readonly code: string;
-    constructor(error: unknown, status: number, code?: string, cause?: unknown);
+    readonly statusText: string;
+    readonly headers: Record<string, string> | undefined;
+    constructor(error: unknown, status: number, statusText?: string, cause?: unknown, headers?: Record<string, string>);
 }

package/dist/errors/gateway.js

@@ -1,13 +1,19 @@
-import { STATUS_CODE } from "./utils";
+import { X_SHOULD_RETRY_HEADER } from "../utils/headers";
+import { STATUS_TEXT } from "./utils";
 export class GatewayError extends Error {
     status;
-    code;
-    constructor(error, status, code, cause) {
+    statusText;
+    headers;
+    constructor(error, status, statusText, cause, headers) {
         const isError = error instanceof Error;
         super(isError ? error.message : String(error));
         this.name = "GatewayError";
         this.cause = cause ?? (isError ? error : undefined);
         this.status = status;
-        this.code = code ?? STATUS_CODE(status);
+        this.statusText = statusText ?? STATUS_TEXT(status);
+        this.headers = headers;
+        if (!this.statusText.startsWith("UPSTREAM_")) {
+            (this.headers ??= {})[X_SHOULD_RETRY_HEADER] = "false";
+        }
     }
 }

package/dist/errors/openai.d.ts

@@ -9,7 +9,8 @@ export declare const OpenAIErrorSchema: z.ZodObject<{
 }, z.core.$strip>;
 export declare class OpenAIError {
     readonly error: z.infer<typeof OpenAIErrorSchema>["error"];
+    status: number;
     constructor(message: string, type?: string, code?: string, param?: string);
 }
-export declare function toOpenAIError(error: unknown): OpenAIError;
-export declare function toOpenAIErrorResponse(error: unknown, responseInit?: ResponseInit): Response;
+export declare function toOpenAIError(error: unknown, requestId?: string): OpenAIError;
+export declare function toOpenAIErrorResponse(error: unknown, init: ResponseInit): Response;

package/dist/errors/openai.js

@@ -14,18 +14,17 @@ export class OpenAIError {
     error;
     constructor(message, type = "server_error", code, param = "") {
         this.error = { message, type, code: code?.toLowerCase(), param };
+        // internal property to derive status from error handlers without breaking official format
+        Object.defineProperty(this, "status", { value: 500, writable: true });
     }
 }
 const mapType = (status) => (status < 500 ? "invalid_request_error" : "server_error");
-export function toOpenAIError(error) {
+export function toOpenAIError(error, requestId) {
     const meta = getErrorMeta(error);
-    return new OpenAIError(maybeMaskMessage(meta), mapType(meta.status), meta.code);
+    const openAIError = new OpenAIError(maybeMaskMessage(error instanceof Error ? error.message : String(error), meta.status, requestId), mapType(meta.status), meta.statusText);
+    openAIError.status = meta.status;
+    return openAIError;
 }
-export function toOpenAIErrorResponse(error, responseInit) {
-    const meta = getErrorMeta(error);
-    return toResponse(new OpenAIError(maybeMaskMessage(meta, resolveRequestId(responseInit)), mapType(meta.status), meta.code), {
-        ...responseInit,
-        status: meta.status,
-        statusText: meta.code,
-    });
+export function toOpenAIErrorResponse(error, init) {
+    return toResponse(new OpenAIError(maybeMaskMessage(error instanceof Error ? error.message : String(error), init.status ?? 500, resolveRequestId(init)), mapType(init.status ?? 500), init.statusText ?? "INTERNAL_SERVER_ERROR"), init);
 }

package/dist/errors/utils.d.ts

@@ -16,11 +16,11 @@ export declare const STATUS_CODES: {
     readonly 503: "SERVICE_UNAVAILABLE";
     readonly 504: "GATEWAY_TIMEOUT";
 };
-export declare const STATUS_CODE: (status: number) => "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "CONFLICT" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_ENTITY" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST" | "INTERNAL_SERVER_ERROR" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT";
+export declare const STATUS_TEXT: (status: number) => "BAD_REQUEST" | "UNAUTHORIZED" | "PAYMENT_REQUIRED" | "FORBIDDEN" | "NOT_FOUND" | "METHOD_NOT_ALLOWED" | "CONFLICT" | "PAYLOAD_TOO_LARGE" | "UNSUPPORTED_MEDIA_TYPE" | "UNPROCESSABLE_ENTITY" | "TOO_MANY_REQUESTS" | "CLIENT_CLOSED_REQUEST" | "INTERNAL_SERVER_ERROR" | "BAD_GATEWAY" | "SERVICE_UNAVAILABLE" | "GATEWAY_TIMEOUT";
 export type ErrorMeta = {
     status: number;
-    code: string;
-    message: string;
+    statusText: string;
+    headers: Record<string, string>;
 };
 export declare function getErrorMeta(error: unknown): ErrorMeta;
-export declare function maybeMaskMessage(meta: ErrorMeta, requestId?: string): string;
+export declare function maybeMaskMessage(message: string, status: number, requestId?: string): string;

package/dist/errors/utils.js

@@ -19,37 +19,37 @@ export const STATUS_CODES = {
     503: "SERVICE_UNAVAILABLE",
     504: "GATEWAY_TIMEOUT",
 };
-export const STATUS_CODE = (status) => {
+export const STATUS_TEXT = (status) => {
     const label = STATUS_CODES[status];
     if (label)
         return label;
     return status >= 400 && status < 500 ? STATUS_CODES[400] : STATUS_CODES[500];
 };
-// FUTURE: always return a wrapped GatewayError?
 export function getErrorMeta(error) {
-    const message = error instanceof Error ? error.message : String(error);
     let status;
-    let code;
+    let statusText;
+    let headers;
     if (error instanceof GatewayError) {
-        ({ status, code } = error);
+        ({ status, statusText, headers } = error);
     }
     else {
         const normalized = normalizeAiSdkError(error);
         if (normalized) {
-            ({ status, code } = normalized);
+            ({ status, statusText, headers } = normalized);
         }
         else {
             status = 500;
-            code = STATUS_CODE(status);
+            statusText = STATUS_TEXT(status);
+            headers = {};
         }
     }
-    return { status, code, message };
+    return { status, statusText, headers: headers ?? {} };
 }
-export function maybeMaskMessage(meta, requestId) {
+export function maybeMaskMessage(message, status, requestId) {
     // FUTURE: consider masking all upstream errors, also 4xx
-    if (!(isProduction() && meta.status >= 500)) {
-        return meta.message;
+    if (!(isProduction() && status >= 500)) {
+        return message;
     }
     // FUTURE: always attach requestId to errors (masked and unmasked)
-    return `${STATUS_CODE(meta.status)} (${requestId ?? "see requestId in response headers"})`;
+    return `${STATUS_TEXT(status)} (${requestId ?? "see requestId in response headers"})`;
 }

package/dist/lifecycle.js

@@ -2,6 +2,7 @@ import { parseConfig } from "./config";
 import { toAnthropicError, toAnthropicErrorResponse } from "./errors/anthropic";
 import { GatewayError } from "./errors/gateway";
 import { toOpenAIError, toOpenAIErrorResponse } from "./errors/openai";
+import { getErrorMeta } from "./errors/utils";
 import { logger } from "./logger";
 import { getBaggageAttributes } from "./telemetry/baggage";
 import { instrumentFetch } from "./telemetry/fetch";
@@ -53,8 +54,7 @@ export const winterCgHandler = (run, config) => {
                     requestId: ctx.requestId,
                     err: reason ?? ctx.request.signal.reason,
                 });
-                const isUpstreamError = reason instanceof GatewayError && reason.code.startsWith("UPSTREAM_");
-                span.recordError(reason, realStatus >= 500 || isUpstreamError);
+                span.recordError(reason, true);
             }
             span.setAttributes({ "http.response.status_code_effective": realStatus });
             if (ctx.operation === "chat" ||
@@ -76,10 +76,10 @@ export const winterCgHandler = (run, config) => {
                 }
                 if (!ctx.response) {
                     ctx.result = (await run(ctx, parsedConfig));
-                    const formatError = ctx.operation === "messages" ? toAnthropicError : toOpenAIError;
-                    ctx.response = toResponse(ctx.result, prepareResponseInit(ctx.requestId), {
+                    const toError = ctx.operation === "messages" ? toAnthropicError : toOpenAIError;
+                    ctx.response = toResponse(ctx.result, prepareResponseInit(ctx.requestId, ctx.response), {
                         onDone: finalize,
-                        formatError,
+                        toError: (error) => toError(error, ctx.requestId),
                     });
                 }
                 if (parsedConfig.hooks?.onResponse) {
@@ -111,11 +111,10 @@ export const winterCgHandler = (run, config) => {
                 const errorPayload = ctx.request.signal.aborted
                     ? new GatewayError(error ?? ctx.request.signal.reason, 499)
                     : error;
-                const errorResponseInit = prepareResponseInit(ctx.requestId);
-                ctx.response ??=
-                    ctx.operation === "messages"
-                        ? toAnthropicErrorResponse(errorPayload, errorResponseInit)
-                        : toOpenAIErrorResponse(errorPayload, errorResponseInit);
+                if (!(ctx.response instanceof Response)) {
+                    const toErrorResponse = ctx.operation === "messages" ? toAnthropicErrorResponse : toOpenAIErrorResponse;
+                    ctx.response = toErrorResponse(errorPayload, prepareResponseInit(ctx.requestId, getErrorMeta(errorPayload)));
+                }
                 finalize(ctx.response.status, error);
             }
         });

package/dist/telemetry/gen-ai.js

@@ -1,5 +1,5 @@
 import { metrics } from "@opentelemetry/api";
-import { STATUS_CODE } from "../errors/utils";
+import { STATUS_TEXT } from "../errors/utils";
 const getMeter = () => metrics.getMeter("@hebo/gateway");
 let requestDurationHistogram;
 let timePerOutputTokenHistogram;
@@ -75,7 +75,7 @@ export const recordRequestDuration = (duration, status, ctx, signalLevel) => {
         return;
     const attrs = getGenAiGeneralAttributes(ctx, signalLevel);
     if (status !== 200) {
-        attrs["error.type"] = `${status} ${STATUS_CODE(status).toLowerCase()}`;
+        attrs["error.type"] = `${status} ${STATUS_TEXT(status).toLowerCase()}`;
     }
     getRequestDurationHistogram().record(duration / 1000, attrs);
 };

package/dist/types.d.ts

@@ -69,8 +69,10 @@ export type GatewayContext = {
     result?: ChatCompletions | ChatCompletionsStream | Embeddings | Messages | MessagesStream | Model | ModelList | Responses | ResponsesStream;
     /**
      * Response object returned by the handler.
+     * Handlers may set this to a `ResponseInit` containing upstream response
+     * headers; the lifecycle merges allowlisted headers into the final `Response`.
      */
-    response?: Response;
+    response?: Response | ResponseInit;
     /**
      * Per-request telemetry signal level override.
      * When set (via body parameter or hook), overrides `cfg.telemetry.signals.gen_ai`

package/dist/utils/headers.d.ts

@@ -1,4 +1,9 @@
 export declare const REQUEST_ID_HEADER = "x-request-id";
+export declare const RETRY_AFTER_HEADER = "retry-after";
+export declare const RETRY_AFTER_MS_HEADER = "retry-after-ms";
+export declare const X_SHOULD_RETRY_HEADER = "x-should-retry";
 type HeaderSource = Request | ResponseInit | undefined;
 export declare const resolveRequestId: (source: HeaderSource) => string | undefined;
+export declare const filterResponseHeaders: (upstream?: HeadersInit) => Record<string, string>;
+export declare const buildRetryHeaders: (status: number, upstream?: Record<string, string>) => Record<string, string>;
 export {};

package/dist/utils/headers.js

@@ -1,22 +1,69 @@
 export const REQUEST_ID_HEADER = "x-request-id";
+export const RETRY_AFTER_HEADER = "retry-after";
+export const RETRY_AFTER_MS_HEADER = "retry-after-ms";
+export const X_SHOULD_RETRY_HEADER = "x-should-retry";
+const RESPONSE_HEADER_ALLOWLIST = [
+    RETRY_AFTER_HEADER,
+    RETRY_AFTER_MS_HEADER,
+    X_SHOULD_RETRY_HEADER,
+];
+const RETRYABLE_STATUS_CODES = new Set([408, 409, 429, 500, 502, 503, 504]);
+const DEFAULT_RETRY_AFTER_MS = 1000;
 export const resolveRequestId = (source) => {
     if (!source)
         return undefined;
     if (source instanceof Request) {
         return source.headers.get(REQUEST_ID_HEADER) ?? undefined;
     }
-    const headers = source.headers;
-    if (!headers)
+    if (!source.headers)
         return undefined;
+    return getHeader(source.headers, REQUEST_ID_HEADER);
+};
+function getHeader(headers, key) {
     if (headers instanceof Headers) {
-        return headers.get(REQUEST_ID_HEADER) ?? undefined;
+        return headers.get(key) ?? undefined;
     }
     if (Array.isArray(headers)) {
-        for (const [key, value] of headers) {
-            if (key.toLowerCase() === REQUEST_ID_HEADER)
-                return value;
+        for (const [k, v] of headers) {
+            if (k.toLowerCase() === key.toLowerCase()) {
+                return v;
+            }
+        }
+        return undefined;
+    }
+    return headers[key] ?? headers[key.toLowerCase()];
+}
+export const filterResponseHeaders = (upstream) => {
+    if (!upstream)
+        return {};
+    const filtered = {};
+    for (const key of RESPONSE_HEADER_ALLOWLIST) {
+        const value = getHeader(upstream, key);
+        if (value !== undefined) {
+            filtered[key] = value;
         }
+    }
+    return filtered;
+};
+function deriveRetryAfterMs(retryAfter) {
+    if (retryAfter === undefined)
+        return undefined;
+    const num = Number(retryAfter);
+    if (Number.isFinite(num) && num > 0)
+        return num * 1000;
+    const dateMs = Date.parse(retryAfter);
+    if (!Number.isFinite(dateMs))
         return undefined;
+    const deltaMs = dateMs - Date.now();
+    return deltaMs > 0 ? deltaMs : undefined;
+}
+export const buildRetryHeaders = (status, upstream = {}) => {
+    if (!RETRYABLE_STATUS_CODES.has(status)) {
+        upstream[X_SHOULD_RETRY_HEADER] = "false";
+        return upstream;
     }
-    return headers[REQUEST_ID_HEADER];
+    upstream[RETRY_AFTER_MS_HEADER] ??= String(deriveRetryAfterMs(upstream[RETRY_AFTER_HEADER]) ?? DEFAULT_RETRY_AFTER_MS);
+    upstream[RETRY_AFTER_HEADER] = String(Math.ceil((Number(upstream[RETRY_AFTER_MS_HEADER]) || DEFAULT_RETRY_AFTER_MS) / 1000));
+    upstream[X_SHOULD_RETRY_HEADER] ??= "true";
+    return upstream;
 };

package/dist/utils/response.d.ts

@@ -1,7 +1,7 @@
 import type { SseFrame } from "./stream";
-export declare const prepareResponseInit: (requestId: string) => ResponseInit;
-export declare const mergeResponseInit: (defaultHeaders: HeadersInit, responseInit?: ResponseInit) => ResponseInit;
+export declare const prepareResponseInit: (requestId: string, upstream?: ResponseInit) => ResponseInit;
+export declare const mergeResponseInit: (headers: Record<string, string>, responseInit?: ResponseInit) => ResponseInit;
 export declare const toResponse: (result: ReadableStream<SseFrame> | Uint8Array<ArrayBuffer> | object | string, responseInit?: ResponseInit, streamOptions?: {
     onDone?: (status: number, reason?: unknown) => void;
-    formatError?: (error: unknown) => unknown;
+    toError?: (error: unknown) => unknown;
 }) => Response;

package/dist/utils/response.js

@@ -1,19 +1,23 @@
-import { REQUEST_ID_HEADER } from "./headers";
+import { buildRetryHeaders, filterResponseHeaders, REQUEST_ID_HEADER } from "./headers";
 import { toSseStream } from "./stream";
 const TEXT_ENCODER = new TextEncoder();
-export const prepareResponseInit = (requestId) => ({
-    headers: { [REQUEST_ID_HEADER]: requestId },
-});
-export const mergeResponseInit = (defaultHeaders, responseInit) => {
-    const headers = new Headers(defaultHeaders);
+export const prepareResponseInit = (requestId, upstream) => {
+    const init = upstream ?? {};
+    init.headers = filterResponseHeaders(upstream?.headers);
+    if (init.status && init.status >= 400)
+        init.headers = buildRetryHeaders(init.status, init.headers);
+    init.headers[REQUEST_ID_HEADER] = requestId;
+    return init;
+};
+export const mergeResponseInit = (headers, responseInit) => {
+    if (!responseInit)
+        return { headers };
     const override = responseInit?.headers;
     if (override) {
         new Headers(override).forEach((value, key) => {
-            headers.set(key, value);
+            headers[key] = value;
         });
     }
-    if (!responseInit)
-        return { headers };
     return {
         status: responseInit.status,
         statusText: responseInit.statusText,

package/dist/utils/stream.d.ts

@@ -5,6 +5,6 @@ export type SseFrame<T = unknown, E extends string | undefined = string | undefi
 export type SseErrorFrame = SseFrame<Error, "error" | undefined>;
 export declare function toSseStream(src: ReadableStream<SseFrame>, options?: {
     onDone?: (status: number, reason?: unknown) => void;
+    toError?: (error: unknown) => unknown;
     keepAliveMs?: number;
-    formatError?: (error: unknown) => unknown;
 }): ReadableStream<Uint8Array>;

package/dist/utils/stream.js

@@ -1,4 +1,3 @@
-import { toOpenAIError } from "../errors/openai";
 const TEXT_ENCODER = new TextEncoder();
 const SSE_DONE_CHUNK = TEXT_ENCODER.encode("data: [DONE]\n\n");
 const SSE_KEEP_ALIVE_CHUNK = TEXT_ENCODER.encode(": keep-alive\n\n");
@@ -59,13 +58,9 @@ export function toSseStream(src, options = {}) {
                 }
                 const value = result.value;
                 if (value.event === "error" || value.data instanceof Error) {
-                    const error = options.formatError
-                        ? options.formatError(value.data)
-                        : toOpenAIError(value.data);
+                    const error = options.toError?.(value.data) ?? value.data;
                     controller.enqueue(TEXT_ENCODER.encode(serializeSseFrame({ event: value.event, data: error })));
-                    const openAiError = toOpenAIError(value.data);
-                    const errorStatus = openAiError?.error.type === "invalid_request_error" ? 422 : 502;
-                    done(controller, errorStatus, value.data);
+                    done(controller, error["status"] ?? 502, value.data);
                     reader.cancel(value.data).catch(() => { });
                     return;
                 }
@@ -74,12 +69,9 @@ export function toSseStream(src, options = {}) {
             }
             catch (error) {
                 try {
-                    const errorPayload = options.formatError
-                        ? options.formatError(error)
-                        : toOpenAIError(error);
                     controller.enqueue(TEXT_ENCODER.encode(serializeSseFrame({
                         event: "error",
-                        data: errorPayload,
+                        data: options.toError?.(error) ?? error,
                     })));
                 }
                 catch { }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.10.5",
+  "version": "0.10.7",
   "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI /chat/completions, OpenResponses /responses & Anthropic /messages.",
   "keywords": [
     "ai",