@hebo-ai/gateway 0.9.3 → 0.10.0

package/dist/endpoints/shared/schema.js

@@ -8,15 +8,17 @@ import * as z from "zod";
 // Note: The 16-key limit is not currently validated.
 export const CacheControlSchema = z.object({
     type: z.literal("ephemeral"),
-    ttl: z.string().optional(),
+    ttl: z.enum(["5m", "1h", "24h"]).optional(),
 });
 export const ProviderMetadataSchema = z.record(z.string(), z.record(z.string(), z.any()));
 export const ReasoningEffortSchema = z.enum(["none", "minimal", "low", "medium", "high", "xhigh"]);
+export const ReasoningSummarySchema = z.enum(["auto", "concise", "detailed", "none"]);
 export const ReasoningConfigSchema = z.object({
     enabled: z.optional(z.boolean()),
     effort: z.optional(ReasoningEffortSchema),
     max_tokens: z.optional(z.number()),
     exclude: z.optional(z.boolean()),
+    summary: z.optional(ReasoningSummarySchema),
 });
 export const ServiceTierSchema = z.enum(["auto", "default", "flex", "scale", "priority"]);
 const InputAudioFormatSchema = z.enum([

package/dist/errors/anthropic.d.ts

@@ -0,0 +1,10 @@
+export declare class AnthropicError {
+    readonly type = "error";
+    readonly error: {
+        type: string;
+        message: string;
+    };
+    constructor(message: string, type?: string);
+}
+export declare function toAnthropicError(error: unknown): AnthropicError;
+export declare function toAnthropicErrorResponse(error: unknown, responseInit?: ResponseInit): Response;

package/dist/errors/anthropic.js

@@ -0,0 +1,46 @@
+import { resolveRequestId } from "../utils/headers";
+import { toResponse } from "../utils/response";
+import { getErrorMeta, maybeMaskMessage } from "./utils";
+export class AnthropicError {
+    type = "error";
+    error;
+    constructor(message, type = "api_error") {
+        this.error = { type, message };
+    }
+}
+const mapType = (status) => {
+    switch (status) {
+        case 400:
+            return "invalid_request_error";
+        case 401:
+            return "authentication_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:
+            return "rate_limit_error";
+        case 504:
+            return "timeout_error";
+        case 529:
+            return "overloaded_error";
+        default:
+            return status >= 500 ? "api_error" : "invalid_request_error";
+    }
+};
+export function toAnthropicError(error) {
+    const meta = getErrorMeta(error);
+    return new AnthropicError(maybeMaskMessage(meta), mapType(meta.status));
+}
+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,
+    });
+}

package/dist/errors/openai.js

@@ -1,8 +1,7 @@
 import * as z from "zod";
-import { isProduction } from "../utils/env";
 import { resolveRequestId } from "../utils/headers";
 import { toResponse } from "../utils/response";
-import { getErrorMeta, STATUS_CODE } from "./utils";
+import { getErrorMeta, maybeMaskMessage } from "./utils";
 export const OpenAIErrorSchema = z.object({
     error: z.object({
         message: z.string(),
@@ -18,14 +17,6 @@ export class OpenAIError {
     }
 }
 const mapType = (status) => (status < 500 ? "invalid_request_error" : "server_error");
-const maybeMaskMessage = (meta, requestId) => {
-    // FUTURE: consider masking all upstream errors, also 4xx
-    if (!(isProduction() && meta.status >= 500)) {
-        return meta.message;
-    }
-    // FUTURE: always attach requestId to errors (masked and unmasked)
-    return `${STATUS_CODE(meta.status)} (${requestId ?? "see requestId in response headers"})`;
-};
 export function toOpenAIError(error) {
     const meta = getErrorMeta(error);
     return new OpenAIError(maybeMaskMessage(meta), mapType(meta.status), meta.code);

package/dist/errors/utils.d.ts

@@ -17,8 +17,10 @@ export declare const STATUS_CODES: {
     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 function getErrorMeta(error: unknown): {
+export type ErrorMeta = {
     status: number;
     code: string;
     message: string;
 };
+export declare function getErrorMeta(error: unknown): ErrorMeta;
+export declare function maybeMaskMessage(meta: ErrorMeta, requestId?: string): string;

package/dist/errors/utils.js

@@ -1,3 +1,4 @@
+import { isProduction } from "../utils/env";
 import { normalizeAiSdkError } from "./ai-sdk";
 import { GatewayError } from "./gateway";
 export const STATUS_CODES = {
@@ -44,3 +45,11 @@ export function getErrorMeta(error) {
     }
     return { status, code, message };
 }
+export function maybeMaskMessage(meta, requestId) {
+    // FUTURE: consider masking all upstream errors, also 4xx
+    if (!(isProduction() && meta.status >= 500)) {
+        return meta.message;
+    }
+    // FUTURE: always attach requestId to errors (masked and unmasked)
+    return `${STATUS_CODE(meta.status)} (${requestId ?? "see requestId in response headers"})`;
+}

package/dist/gateway.d.ts

@@ -6,6 +6,7 @@ export declare function gateway(config: GatewayConfig): {
         readonly "/embeddings": Endpoint;
         readonly "/models": Endpoint;
         readonly "/conversations": Endpoint;
+        readonly "/messages": Endpoint;
         readonly "/responses": Endpoint;
     };
 };

package/dist/gateway.js

@@ -2,6 +2,7 @@ import { parseConfig } from "./config";
 import { chatCompletions } from "./endpoints/chat-completions/handler";
 import { conversations } from "./endpoints/conversations/handler";
 import { embeddings } from "./endpoints/embeddings/handler";
+import { messages } from "./endpoints/messages/handler";
 import { models } from "./endpoints/models/handler";
 import { responses } from "./endpoints/responses/handler";
 import { GatewayError } from "./errors/gateway";
@@ -19,6 +20,7 @@ export function gateway(config) {
         ["/embeddings"]: embeddings(parsedConfig),
         ["/models"]: models(parsedConfig),
         ["/conversations"]: conversations(parsedConfig),
+        ["/messages"]: messages(parsedConfig),
         ["/responses"]: responses(parsedConfig),
     };
     const routeEntries = Object.entries(routes);

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./gateway";
 export type * from "./types";
+export * from "./errors/anthropic";
 export * from "./errors/gateway";
 export * from "./errors/openai";
 export * from "./logger";

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from "./gateway";
+export * from "./errors/anthropic";
 export * from "./errors/gateway";
 export * from "./errors/openai";
 export * from "./logger";

package/dist/lifecycle.js

@@ -1,6 +1,7 @@
 import { parseConfig } from "./config";
+import { toAnthropicError, toAnthropicErrorResponse } from "./errors/anthropic";
 import { GatewayError } from "./errors/gateway";
-import { toOpenAIErrorResponse } from "./errors/openai";
+import { toOpenAIError, toOpenAIErrorResponse } from "./errors/openai";
 import { logger } from "./logger";
 import { getBaggageAttributes } from "./telemetry/baggage";
 import { instrumentFetch } from "./telemetry/fetch";
@@ -57,6 +58,7 @@ export const winterCgHandler = (run, config) => {
             span.setAttributes({ "http.response.status_code_effective": realStatus });
             if (ctx.operation === "chat" ||
                 ctx.operation === "embeddings" ||
+                ctx.operation === "messages" ||
                 ctx.operation === "responses") {
                 recordRequestDuration(performance.now() - start, realStatus, ctx, parsedConfig.telemetry?.signals?.gen_ai);
             }
@@ -73,8 +75,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), {
                         onDone: finalize,
+                        formatError,
                     });
                 }
                 if (parsedConfig.hooks?.onResponse) {
@@ -103,9 +107,14 @@ export const winterCgHandler = (run, config) => {
                         logger.debug("[lifecycle] onError hook threw");
                     }
                 }
-                ctx.response ??= toOpenAIErrorResponse(ctx.request.signal.aborted
+                const errorPayload = ctx.request.signal.aborted
                     ? new GatewayError(error ?? ctx.request.signal.reason, 499)
-                    : error, prepareResponseInit(ctx.requestId));
+                    : error;
+                const errorResponseInit = prepareResponseInit(ctx.requestId);
+                ctx.response ??=
+                    ctx.operation === "messages"
+                        ? toAnthropicErrorResponse(errorPayload, errorResponseInit)
+                        : toOpenAIErrorResponse(errorPayload, errorResponseInit);
                 finalize(ctx.response.status, error);
             }
         });

package/dist/models/anthropic/middleware.js

@@ -102,6 +102,11 @@ export const claudeReasoningMiddleware = {
         else {
             target.thinking = { type: "enabled" };
         }
+        // Map reasoning.summary to Anthropic thinking.display
+        const thinkingDisplay = reasoning.summary === "none" ? "omitted" : reasoning.summary ? "summarized" : undefined;
+        if (thinkingDisplay && target.thinking && target.thinking.type !== "disabled") {
+            target.thinking["display"] = thinkingDisplay;
+        }
         delete unknown["reasoning"];
         return params;
     },

package/dist/providers/bedrock/middleware.js

@@ -1,4 +1,5 @@
 import { modelMiddlewareMatcher } from "../../middleware/matcher";
+import { calculateReasoningBudgetFromEffort } from "../../middleware/utils";
 const isClaude46 = (modelId) => modelId.includes("-4-6");
 // https://docs.aws.amazon.com/bedrock/latest/userguide/service-tiers-inference.html
 export const bedrockServiceTierMiddleware = {
@@ -62,10 +63,24 @@ export const bedrockClaudeReasoningMiddleware = {
             return params;
         const target = (bedrock.reasoningConfig ??= {});
         if (thinking && typeof thinking === "object") {
-            target.type = thinking.type;
+            // Bedrock's InvokeModel (Messages) API supports "adaptive" thinking natively,
+            // but @ai-sdk/amazon-bedrock only uses the Converse API which rejects "adaptive"
+            // in additionalModelRequestFields — it only accepts "enabled" / "disabled".
+            // Map "adaptive" → "enabled" until the SDK adds InvokeModel support.
+            // See: https://docs.aws.amazon.com/bedrock/latest/userguide/claude-messages-adaptive-thinking.html
+            // SDK tracking issue: https://github.com/vercel/ai/issues/8513
+            target.type = thinking.type === "adaptive" ? "enabled" : thinking.type;
             if ("budgetTokens" in thinking && thinking.budgetTokens !== undefined) {
                 target.budgetTokens = thinking.budgetTokens;
             }
+            else if (target.type === "enabled") {
+                // Bedrock requires budgetTokens when type is "enabled". When mapping from
+                // "adaptive" (which doesn't require budgetTokens), compute a fallback using
+                // the same effort-based logic as other model cases, defaulting to "medium".
+                // Note: Bedrock Converse API doesn't support "adaptive" natively — see vercel/ai#8513
+                const mappedEffort = effort === "max" ? "xhigh" : effort ?? "medium";
+                target.budgetTokens = calculateReasoningBudgetFromEffort(mappedEffort, params.maxOutputTokens ?? 65536, 1024);
+            }
         }
         // FUTURE: bedrock currently does not support "effort" for other 4.x models
         if (effort !== undefined && isClaude46(model.modelId)) {

package/dist/providers/registry.d.ts

@@ -5,7 +5,7 @@ export declare const resolveProvider: (args: {
     providers: ProviderRegistry;
     models: ModelCatalog;
     modelId: ModelId;
-    operation: "chat" | "embeddings" | "responses";
+    operation: "chat" | "embeddings" | "messages" | "responses";
 }) => ProviderV3;
 export type CanonicalIdsOptions = {
     mapping?: Partial<Record<ModelId, string>>;

package/dist/telemetry/gen-ai.js

@@ -54,12 +54,16 @@ export const getGenAiGeneralAttributes = (ctx, signalLevel) => {
     if (!signalLevel || signalLevel === "off")
         return {};
     const requestModel = typeof ctx.body?.model === "string" ? ctx.body.model : ctx.modelId;
+    const serviceTier = typeof ctx.body?.service_tier === "string" ? ctx.body.service_tier : undefined;
     const attrs = {
         "gen_ai.operation.name": ctx.operation,
         "gen_ai.request.model": requestModel,
         "gen_ai.response.model": ctx.resolvedModelId,
         "gen_ai.provider.name": ctx.resolvedProviderId,
     };
+    if (signalLevel !== "required" && serviceTier !== undefined) {
+        attrs["gen_ai.request.service_tier"] = serviceTier;
+    }
     for (const [key, value] of Object.entries(ctx.otel)) {
         if (value !== undefined)
             attrs[key] = value;

package/dist/types.d.ts

@@ -3,12 +3,13 @@ import type { Attributes, Tracer } from "@opentelemetry/api";
 import type { ChatCompletions, ChatCompletionsBody, ChatCompletionsStream } from "./endpoints/chat-completions/schema";
 import type { ConversationStorage } from "./endpoints/conversations/storage/types";
 import type { Embeddings, EmbeddingsBody } from "./endpoints/embeddings/schema";
+import type { Messages, MessagesBody, MessagesStream } from "./endpoints/messages/schema";
 import type { Model, ModelList } from "./endpoints/models";
 import type { Responses, ResponsesBody, ResponsesStream } from "./endpoints/responses/schema";
 import type { Logger, LoggerConfig } from "./logger";
 import type { ModelCatalog, ModelId } from "./models/types";
 import type { ProviderId, ProviderRegistry } from "./providers/types";
-export type GatewayOperation = "chat" | "embeddings" | "responses" | "models" | "conversations";
+export type GatewayOperation = "chat" | "embeddings" | "messages" | "responses" | "models" | "conversations";
 /**
  * Per-request context shared across handlers and hooks.
  */
@@ -41,7 +42,7 @@ export type GatewayContext = {
     /**
      * Parsed body from the request.
      */
-    body?: ChatCompletionsBody | EmbeddingsBody | ResponsesBody;
+    body?: ChatCompletionsBody | EmbeddingsBody | MessagesBody | ResponsesBody;
     /**
      * Incoming model ID.
      */
@@ -65,7 +66,7 @@ export type GatewayContext = {
     /**
      * Result returned by the handler (pre-response).
      */
-    result?: ChatCompletions | ChatCompletionsStream | Embeddings | Model | ModelList | Responses | ResponsesStream;
+    result?: ChatCompletions | ChatCompletionsStream | Embeddings | Messages | MessagesStream | Model | ModelList | Responses | ResponsesStream;
     /**
      * Response object returned by the handler.
      */
@@ -103,7 +104,7 @@ export type GatewayHooks = {
      * Runs after request JSON is parsed and validated for chat completions / embeddings / responses.
      * @returns Replacement parsed body, or undefined to keep original.
      */
-    before?: (ctx: BeforeHookContext) => void | ChatCompletionsBody | EmbeddingsBody | ResponsesBody | Promise<void | ChatCompletionsBody | EmbeddingsBody | ResponsesBody>;
+    before?: (ctx: BeforeHookContext) => void | ChatCompletionsBody | EmbeddingsBody | MessagesBody | ResponsesBody | Promise<void | ChatCompletionsBody | EmbeddingsBody | MessagesBody | ResponsesBody>;
     /**
      * Maps a user-provided model ID or alias to a canonical ID.
      * @returns Canonical model ID or undefined to keep original.
@@ -118,7 +119,7 @@ export type GatewayHooks = {
      * Runs after the endpoint handler.
      * @returns Result to replace, or undefined to keep original.
      */
-    after?: (ctx: AfterHookContext) => void | ChatCompletions | ChatCompletionsStream | Embeddings | Model | ModelList | Responses | ResponsesStream | Promise<void | ChatCompletions | ChatCompletionsStream | Embeddings | Model | ModelList | Responses | ResponsesStream>;
+    after?: (ctx: AfterHookContext) => void | ChatCompletions | ChatCompletionsStream | Embeddings | Messages | MessagesStream | Model | ModelList | Responses | ResponsesStream | Promise<void | ChatCompletions | ChatCompletionsStream | Embeddings | Messages | MessagesStream | Model | ModelList | Responses | ResponsesStream>;
     /**
      * Runs after the lifecycle has produced the final Response.
      * @returns Replacement Response, or undefined to keep original.

package/dist/utils/response.d.ts

@@ -3,4 +3,5 @@ export declare const prepareResponseInit: (requestId: string) => ResponseInit;
 export declare const mergeResponseInit: (defaultHeaders: HeadersInit, 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;
 }) => Response;

package/dist/utils/stream.d.ts

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

package/dist/utils/stream.js

@@ -59,9 +59,13 @@ export function toSseStream(src, options = {}) {
                 }
                 const value = result.value;
                 if (value.event === "error" || value.data instanceof Error) {
-                    const error = toOpenAIError(value.data);
+                    const error = options.formatError
+                        ? options.formatError(value.data)
+                        : toOpenAIError(value.data);
                     controller.enqueue(TEXT_ENCODER.encode(serializeSseFrame({ event: value.event, data: error })));
-                    done(controller, error.error.type === "invalid_request_error" ? 422 : 502, value.data);
+                    const openAiError = toOpenAIError(value.data);
+                    const errorStatus = openAiError?.error.type === "invalid_request_error" ? 422 : 502;
+                    done(controller, errorStatus, value.data);
                     reader.cancel(value.data).catch(() => { });
                     return;
                 }
@@ -70,9 +74,12 @@ 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: toOpenAIError(error),
+                        data: errorPayload,
                     })));
                 }
                 catch { }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.9.3",
-  "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI-compatible /chat/completions, /embeddings & /models.",
+  "version": "0.10.0",
+  "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI /chat/completions, OpenResponses /responses & Anthropic /messages.",
   "keywords": [
     "ai",
     "ai-gateway",
@@ -62,6 +62,10 @@
       "types": "./dist/endpoints/embeddings/index.d.ts",
       "import": "./dist/endpoints/embeddings/index.js"
     },
+    "./endpoints/messages": {
+      "types": "./dist/endpoints/messages/index.d.ts",
+      "import": "./dist/endpoints/messages/index.js"
+    },
     "./endpoints/models": {
       "types": "./dist/endpoints/models/index.d.ts",
       "import": "./dist/endpoints/models/index.js"
@@ -80,6 +84,10 @@
       "import": "./dist/endpoints/conversations/storage/sql.js",
       "dev-source": "./src/endpoints/conversations/storage/sql.ts"
     },
+    "./errors/anthropic": {
+      "types": "./dist/errors/anthropic.d.ts",
+      "import": "./dist/errors/anthropic.js"
+    },
     "./errors/openai": {
       "types": "./dist/errors/openai.d.ts",
       "import": "./dist/errors/openai.js"
@@ -158,7 +166,9 @@
     "lint": "oxlint",
     "lint:staged": "oxlint --fix",
     "typecheck": "oxlint --type-check",
-    "test": "bun test",
+    "test": "bun test src/",
+    "test:e2e": "bun test test/e2e/",
+    "test:all": "bun test",
     "check": "bun lint && bun typecheck",
     "fix": "bun lint:staged && bun format:staged"
   },
@@ -176,6 +186,7 @@
     "@ai-sdk/google-vertex": "^4.0.105",
     "@ai-sdk/groq": "^3.0.35",
     "@ai-sdk/openai": "^3.0.52",
+    "@anthropic-ai/sdk": "^0.88.0",
     "@aws-sdk/credential-providers": "^3.1027.0",
     "@langfuse/otel": "^5.0.2",
     "@libsql/client": "^0.17.2",