@hebo-ai/gateway 0.10.1 → 0.10.3

package/README.md

@@ -926,6 +926,42 @@ These attributes appear on the active span and on all metric instruments (reques
 > To populate custom span attributes, the inbound W3C `baggage` header is supported. Keys in the `hebo.` namespace are mapped to span attributes, with the namespace stripped. For example: `baggage: hebo.user_id=u-123` becomes span attribute `user_id=u-123`.  
 > For `/chat/completions` and `/embeddings`, request `metadata` (`Record<string, string>`, key 1-64 chars, value up to 512 chars) is also forwarded to spans as `gen_ai.request.metadata.<key>`.
 
+#### Per-Request Trace Control
+
+You can override the global `telemetry.signals.gen_ai` level on a per-request basis using the `trace` body parameter. This is useful for selectively enabling detailed traces on specific requests without changing the gateway-wide configuration.
+
+The `trace` parameter is accepted on all endpoints (`/chat/completions`, `/embeddings`, `/messages`, `/responses`):
+
+```json
+{
+  "model": "openai/gpt-oss-20b",
+  "messages": [{ "role": "user", "content": "Hello" }],
+  "trace": "full"
+}
+```
+
+Accepted values:
+
+- `false` — disables tracing for this request (equivalent to `"off"`)
+- `true` — uses the global default (same as omitting the parameter)
+- `"off"` | `"required"` | `"recommended"` | `"full"` — sets the signal level for this request
+
+The resolution order is: **hook-set `ctx.trace`** > **body `trace` parameter** > **`cfg.telemetry.signals.gen_ai`**. This means hooks can always override the body parameter by setting `ctx.trace` directly:
+
+```ts
+hooks: {
+  before: (ctx) => {
+    // Force full tracing for a specific user
+    if (ctx.state.userId === "debug-user") {
+      ctx.trace = "full";
+    }
+  },
+}
+```
+
+> [!NOTE]
+> The `trace` parameter only affects span attributes and metrics signal level — it does not control whether tracing is enabled globally. The `telemetry.enabled` config field must still be `true` for any telemetry to be emitted.
+
 #### Metrics
 
 The Gateway also emits `gen_ai` metrics:

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

@@ -58,18 +58,18 @@ export const chatCompletions = (config) => {
         ctx.resolvedProviderId = languageModel.provider;
         logger.debug(`[chat] using ${languageModel.provider} for ${ctx.resolvedModelId}`);
         addSpanEvent("hebo.provider.resolved");
-        const genAiSignalLevel = cfg.telemetry?.signals?.gen_ai;
-        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
+        ctx.trace ??= ctx.body.trace ?? cfg.telemetry?.signals?.gen_ai;
+        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, ctx.trace);
         setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
-        const { model: _model, stream, ...inputs } = ctx.body;
+        const { model: _model, stream, trace: _trace, ...inputs } = ctx.body;
         const textOptions = convertToTextCallOptions(inputs);
         logger.trace({
             requestId: ctx.requestId,
             options: textOptions,
         }, "[chat] AI SDK options");
         addSpanEvent("hebo.options.prepared");
-        setSpanAttributes(getChatRequestAttributes(ctx.body, genAiSignalLevel));
+        setSpanAttributes(getChatRequestAttributes(ctx.body, ctx.trace));
         // Build middleware chain (model -> forward params -> provider).
         const languageModelWithMiddleware = wrapLanguageModel({
             model: languageModel,
@@ -93,7 +93,7 @@ export const chatCompletions = (config) => {
                 onChunk: () => {
                     if (!ttft) {
                         ttft = performance.now() - start;
-                        recordTimeToFirstToken(ttft, genAiGeneralAttrs, genAiSignalLevel);
+                        recordTimeToFirstToken(ttft, genAiGeneralAttrs, ctx.trace);
                     }
                 },
                 onFinish: (res) => {
@@ -101,10 +101,10 @@ export const chatCompletions = (config) => {
                     const streamResult = toChatCompletions(res, ctx.resolvedModelId);
                     logger.trace({ requestId: ctx.requestId, result: streamResult }, "[chat] ChatCompletions");
                     addSpanEvent("hebo.result.transformed");
-                    const genAiResponseAttrs = getChatResponseAttributes(streamResult, genAiSignalLevel);
+                    const genAiResponseAttrs = getChatResponseAttributes(streamResult, ctx.trace);
                     setSpanAttributes(genAiResponseAttrs);
-                    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-                    recordTimePerOutputToken(start, ttft, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+                    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
+                    recordTimePerOutputToken(start, ttft, genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
                 },
                 experimental_include: {
                     requestBody: false,
@@ -133,19 +133,19 @@ export const chatCompletions = (config) => {
         });
         logger.trace({ requestId: ctx.requestId, result }, "[chat] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
-        recordTimeToFirstToken(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
+        recordTimeToFirstToken(performance.now() - start, genAiGeneralAttrs, ctx.trace);
         // Transform result.
         ctx.result = toChatCompletions(result, ctx.resolvedModelId);
         logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[chat] ChatCompletions");
         addSpanEvent("hebo.result.transformed");
-        const genAiResponseAttrs = getChatResponseAttributes(ctx.result, genAiSignalLevel);
+        const genAiResponseAttrs = getChatResponseAttributes(ctx.result, ctx.trace);
         setSpanAttributes(genAiResponseAttrs);
-        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
         if (hooks?.after) {
             ctx.result = (await hooks.after(ctx)) ?? ctx.result;
             addSpanEvent("hebo.hooks.after.completed");
         }
-        recordTimePerOutputToken(start, 0, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordTimePerOutputToken(start, 0, genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
         return ctx.result;
     };
     return { handler: winterCgHandler(handler, config) };

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

@@ -1041,6 +1041,12 @@ export declare const ChatCompletionsBodySchema: z.ZodObject<{
     extra_body: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
     model: z.ZodString;
     stream: z.ZodOptional<z.ZodBoolean>;
+    trace: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodBoolean, z.ZodTransform<"off" | undefined, boolean>>, z.ZodEnum<{
+        off: "off";
+        required: "required";
+        recommended: "recommended";
+        full: "full";
+    }>]>>;
 }, z.core.$loose>;
 export type ChatCompletionsBody = z.infer<typeof ChatCompletionsBodySchema>;
 export declare const ChatCompletionsFinishReasonSchema: z.ZodEnum<{

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

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import { CacheControlSchema as ChatCompletionsCacheControlSchema, ReasoningEffortSchema as ChatCompletionsReasoningEffortSchema, ReasoningConfigSchema as ChatCompletionsReasoningConfigSchema, ServiceTierSchema as ChatCompletionsServiceTierSchema, ProviderMetadataSchema as ChatCompletionsProviderMetadataSchema, ContentPartAudioSchema as ChatCompletionsContentPartAudioSchema, } from "../shared/schema";
+import { CacheControlSchema as ChatCompletionsCacheControlSchema, ReasoningEffortSchema as ChatCompletionsReasoningEffortSchema, ReasoningConfigSchema as ChatCompletionsReasoningConfigSchema, ServiceTierSchema as ChatCompletionsServiceTierSchema, ProviderMetadataSchema as ChatCompletionsProviderMetadataSchema, ContentPartAudioSchema as ChatCompletionsContentPartAudioSchema, TraceSchema, } from "../shared/schema";
 export { ChatCompletionsCacheControlSchema, ChatCompletionsReasoningEffortSchema, ChatCompletionsReasoningConfigSchema, ChatCompletionsServiceTierSchema, ChatCompletionsProviderMetadataSchema, ChatCompletionsContentPartAudioSchema, };
 export const ChatCompletionsContentPartTextSchema = z.object({
     type: z.literal("text"),
@@ -181,6 +181,7 @@ const ChatCompletionsInputsSchema = z.object({
 export const ChatCompletionsBodySchema = z.looseObject({
     model: z.string(),
     stream: z.boolean().optional(),
+    trace: TraceSchema,
     ...ChatCompletionsInputsSchema.shape,
 });
 export const ChatCompletionsFinishReasonSchema = z.enum([

package/dist/endpoints/conversations/schema.d.ts

@@ -403,6 +403,7 @@ export declare const ConversationItemSchema: z.ZodIntersection<z.ZodObject<{
         incomplete: "incomplete";
     }>>;
     extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+    signature: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "type">>;
 export type ConversationItem = z.infer<typeof ConversationItemSchema>;
 export declare const ConversationSchema: z.ZodObject<{
@@ -819,6 +820,7 @@ export declare const ConversationCreateParamsSchema: z.ZodObject<{
             incomplete: "incomplete";
         }>>;
         extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+        signature: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "type">>>;
     metadata: z.ZodOptional<z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>>>;
 }, z.core.$strip>;
@@ -1225,6 +1227,7 @@ export declare const ConversationItemsAddBodySchema: z.ZodObject<{
             incomplete: "incomplete";
         }>>;
         extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+        signature: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "type">>;
 }, z.core.$strip>;
 export type ConversationItemsAddBody = z.infer<typeof ConversationItemsAddBodySchema>;
@@ -1631,6 +1634,7 @@ export declare const ConversationItemListSchema: z.ZodObject<{
             incomplete: "incomplete";
         }>>;
         extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+        signature: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "type">>>;
     has_more: z.ZodBoolean;
     first_id: z.ZodOptional<z.ZodString>;

package/dist/endpoints/embeddings/handler.js

@@ -57,15 +57,15 @@ export const embeddings = (config) => {
         ctx.resolvedProviderId = embeddingModel.provider;
         logger.debug(`[embeddings] using ${embeddingModel.provider} for ${ctx.resolvedModelId}`);
         addSpanEvent("hebo.provider.resolved");
-        const genAiSignalLevel = cfg.telemetry?.signals?.gen_ai;
-        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
+        ctx.trace ??= ctx.body.trace ?? cfg.telemetry?.signals?.gen_ai;
+        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, ctx.trace);
         setSpanAttributes(genAiGeneralAttrs);
         // Convert inputs to AI SDK call options.
-        const { model: _model, ...inputs } = ctx.body;
+        const { model: _model, trace: _trace, ...inputs } = ctx.body;
         const embedOptions = convertToEmbedCallOptions(inputs);
         logger.trace({ requestId: ctx.requestId, options: embedOptions }, "[embeddings] AI SDK options");
         addSpanEvent("hebo.options.prepared");
-        setSpanAttributes(getEmbeddingsRequestAttributes(ctx.body, genAiSignalLevel));
+        setSpanAttributes(getEmbeddingsRequestAttributes(ctx.body, ctx.trace));
         // Build middleware chain (model -> forward params -> provider).
         const embeddingModelWithMiddleware = wrapEmbeddingModel({
             model: embeddingModel,
@@ -85,14 +85,14 @@ export const embeddings = (config) => {
         ctx.result = toEmbeddings(result, ctx.modelId);
         logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[chat] Embeddings");
         addSpanEvent("hebo.result.transformed");
-        const genAiResponseAttrs = getEmbeddingsResponseAttributes(ctx.result, genAiSignalLevel);
-        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        const genAiResponseAttrs = getEmbeddingsResponseAttributes(ctx.result, ctx.trace);
+        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
         setSpanAttributes(genAiResponseAttrs);
         if (hooks?.after) {
             ctx.result = (await hooks.after(ctx)) ?? ctx.result;
             addSpanEvent("hebo.hooks.after.completed");
         }
-        recordTimePerOutputToken(start, 0, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordTimePerOutputToken(start, 0, genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
         return ctx.result;
     };
     return { handler: winterCgHandler(handler, config) };

package/dist/endpoints/embeddings/schema.d.ts

@@ -14,6 +14,12 @@ export declare const EmbeddingsBodySchema: z.ZodObject<{
     dimensions: z.ZodOptional<z.ZodInt>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     model: z.ZodString;
+    trace: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodBoolean, z.ZodTransform<"off" | undefined, boolean>>, z.ZodEnum<{
+        off: "off";
+        required: "required";
+        recommended: "recommended";
+        full: "full";
+    }>]>>;
 }, z.core.$loose>;
 export type EmbeddingsBody = z.infer<typeof EmbeddingsBodySchema>;
 export declare const EmbeddingsDataSchema: z.ZodObject<{

package/dist/endpoints/embeddings/schema.js

@@ -1,4 +1,5 @@
 import * as z from "zod";
+import { TraceSchema } from "../shared/schema";
 export const EmbeddingsDimensionsSchema = z.int().nonnegative().max(65536);
 export const EmbeddingsMetadataSchema = z.record(z.string().min(1).max(64), z.string().max(512));
 export const EmbeddingsInputsSchema = z.object({
@@ -8,6 +9,7 @@ export const EmbeddingsInputsSchema = z.object({
 });
 export const EmbeddingsBodySchema = z.looseObject({
     model: z.string(),
+    trace: TraceSchema,
     ...EmbeddingsInputsSchema.shape,
 });
 export const EmbeddingsDataSchema = z.object({

package/dist/endpoints/messages/handler.js

@@ -55,14 +55,14 @@ export const messages = (config) => {
         ctx.resolvedProviderId = languageModel.provider;
         logger.debug(`[messages] using ${languageModel.provider} for ${ctx.resolvedModelId}`);
         addSpanEvent("hebo.provider.resolved");
-        const genAiSignalLevel = cfg.telemetry?.signals?.gen_ai;
-        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
+        ctx.trace ??= ctx.body.trace ?? cfg.telemetry?.signals?.gen_ai;
+        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, ctx.trace);
         setSpanAttributes(genAiGeneralAttrs);
-        const { model: _model, stream, ...inputs } = ctx.body;
+        const { model: _model, stream, trace: _trace, ...inputs } = ctx.body;
         const textOptions = convertToTextCallOptions(inputs);
         logger.trace({ requestId: ctx.requestId, options: textOptions }, "[messages] AI SDK options");
         addSpanEvent("hebo.options.prepared");
-        setSpanAttributes(getMessagesRequestAttributes(ctx.body, genAiSignalLevel));
+        setSpanAttributes(getMessagesRequestAttributes(ctx.body, ctx.trace));
         const languageModelWithMiddleware = wrapLanguageModel({
             model: languageModel,
             middleware: modelMiddlewareMatcher.for(ctx.resolvedModelId, languageModel.provider),
@@ -84,7 +84,7 @@ export const messages = (config) => {
                 onChunk: () => {
                     if (!ttft) {
                         ttft = performance.now() - start;
-                        recordTimeToFirstToken(ttft, genAiGeneralAttrs, genAiSignalLevel);
+                        recordTimeToFirstToken(ttft, genAiGeneralAttrs, ctx.trace);
                     }
                 },
                 onFinish: (res) => {
@@ -92,10 +92,10 @@ export const messages = (config) => {
                     const streamResult = toMessages(res, ctx.resolvedModelId);
                     logger.trace({ requestId: ctx.requestId, result: streamResult }, "[messages] Messages");
                     addSpanEvent("hebo.result.transformed");
-                    const genAiResponseAttrs = getMessagesResponseAttributes(streamResult, genAiSignalLevel, res.finishReason);
+                    const genAiResponseAttrs = getMessagesResponseAttributes(streamResult, ctx.trace, res.finishReason);
                     setSpanAttributes(genAiResponseAttrs);
-                    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-                    recordTimePerOutputToken(start, ttft, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+                    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
+                    recordTimePerOutputToken(start, ttft, genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
                 },
                 experimental_include: {
                     requestBody: false,
@@ -124,18 +124,18 @@ export const messages = (config) => {
         });
         logger.trace({ requestId: ctx.requestId, result }, "[messages] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
-        recordTimeToFirstToken(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
+        recordTimeToFirstToken(performance.now() - start, genAiGeneralAttrs, ctx.trace);
         ctx.result = toMessages(result, ctx.resolvedModelId);
         logger.trace({ requestId: ctx.requestId, result: ctx.result }, "[messages] Messages");
         addSpanEvent("hebo.result.transformed");
-        const genAiResponseAttrs = getMessagesResponseAttributes(ctx.result, genAiSignalLevel, result.finishReason);
+        const genAiResponseAttrs = getMessagesResponseAttributes(ctx.result, ctx.trace, result.finishReason);
         setSpanAttributes(genAiResponseAttrs);
-        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
         if (hooks?.after) {
             ctx.result = (await hooks.after(ctx)) ?? ctx.result;
             addSpanEvent("hebo.hooks.after.completed");
         }
-        recordTimePerOutputToken(start, 0, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordTimePerOutputToken(start, 0, genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
         return ctx.result;
     };
     return { handler: winterCgHandler(handler, config) };

package/dist/endpoints/messages/schema.d.ts

@@ -452,6 +452,12 @@ export declare const MessagesBodySchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>]>>;
     stream: z.ZodOptional<z.ZodBoolean>;
+    trace: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodBoolean, z.ZodTransform<"off" | undefined, boolean>>, z.ZodEnum<{
+        off: "off";
+        required: "required";
+        recommended: "recommended";
+        full: "full";
+    }>]>>;
     temperature: z.ZodOptional<z.ZodNumber>;
     top_p: z.ZodOptional<z.ZodNumber>;
     stop_sequences: z.ZodOptional<z.ZodArray<z.ZodString>>;

package/dist/endpoints/messages/schema.js

@@ -1,5 +1,5 @@
 import * as z from "zod";
-import { CacheControlSchema, ProviderMetadataSchema } from "../shared/schema";
+import { CacheControlSchema, ProviderMetadataSchema, TraceSchema } from "../shared/schema";
 // --- Content Block Schemas ---
 const TextBlockSchema = z.object({
     type: z.literal("text"),
@@ -172,6 +172,7 @@ export const MessagesBodySchema = z.object({
     messages: z.array(MessagesMessageSchema),
     system: z.union([z.string(), z.array(SystemBlockSchema)]).optional(),
     stream: z.boolean().optional(),
+    trace: TraceSchema,
     temperature: z.number().optional(),
     top_p: z.number().optional(),
     stop_sequences: z.array(z.string()).optional(),

package/dist/endpoints/responses/converters.js

@@ -91,17 +91,24 @@ export function convertToModelMessages(input, instructions) {
 }
 function fromReasoningItem(item) {
     const parts = [];
-    if (!item.summary || item.summary.length === 0) {
+    // Prefer content (full thinking text) over summary when available
+    const source = item.content && item.content.length > 0 ? item.content : item.summary;
+    if (!source || source.length === 0) {
         return { role: "assistant", content: parts };
     }
     let providerOptions;
-    if (item.extra_content || item.encrypted_content) {
-        providerOptions = item.extra_content ?? { unknown: {} };
+    if (item.extra_content || item.encrypted_content || item.signature) {
+        providerOptions = item.extra_content ? { ...item.extra_content } : { unknown: {} };
+        const existing = (providerOptions["unknown"] ?? {});
         if (item.encrypted_content) {
-            (providerOptions ??= {})["unknown"] = { redactedData: item.encrypted_content };
+            existing["redactedData"] = item.encrypted_content;
         }
+        if (item.signature) {
+            existing["signature"] = item.signature;
+        }
+        providerOptions["unknown"] = existing;
     }
-    for (const s of item.summary) {
+    for (const s of source) {
         parts.push({
             type: "reasoning",
             text: s.text,
@@ -477,13 +484,17 @@ function toReasoningOutputItem(reasoning) {
     };
     if (reasoning.text) {
         item.summary = [{ type: "summary_text", text: reasoning.text }];
+        item.content = [{ type: "reasoning_text", text: reasoning.text }];
     }
     const providerMetadata = reasoning.providerMetadata ?? {};
     item.extra_content = providerMetadata;
-    const { redactedData } = extractReasoningMetadata(providerMetadata);
+    const { redactedData, signature } = extractReasoningMetadata(providerMetadata);
     if (redactedData) {
         item.encrypted_content = redactedData;
     }
+    if (signature) {
+        item.signature = signature;
+    }
     return item;
 }
 function toFunctionCallItem(toolCallId, toolName, input, providerMetadata, status = "completed") {
@@ -560,6 +571,7 @@ export class ResponsesTransformStream extends TransformStream {
         let reasoningItem;
         let reasoningOutputIndex = -1;
         let summaryIndex = 0;
+        let reasoningContentIndex = 0;
         let finishProviderMetadata;
         const outputItems = [];
         const inProgressToolCalls = new Map();
@@ -592,8 +604,13 @@ export class ResponsesTransformStream extends TransformStream {
                             type: "summary_text",
                             text: s.text,
                         })),
+                        content: item.content?.map((c) => ({
+                            type: "reasoning_text",
+                            text: c.text,
+                        })),
                         extra_content: item.extra_content,
                         encrypted_content: item.encrypted_content,
+                        signature: item.signature,
                     };
                 }
                 if (item.type === "function_call") {
@@ -664,6 +681,21 @@ export class ResponsesTransformStream extends TransformStream {
                     });
                 }
             }
+            if (reasoningItem && reasoningItem.content && reasoningItem.content.length > 0) {
+                const lastContentPart = reasoningItem.content[reasoningContentIndex];
+                if (lastContentPart) {
+                    controller.enqueue({
+                        event: "response.reasoning_text.done",
+                        data: {
+                            type: "response.reasoning_text.done",
+                            item_id: reasoningItem.id,
+                            output_index: reasoningOutputIndex,
+                            content_index: reasoningContentIndex,
+                            text: lastContentPart.text,
+                        },
+                    });
+                }
+            }
             if (reasoningItem) {
                 reasoningItem.status = "completed";
                 controller.enqueue({
@@ -813,16 +845,21 @@ export class ResponsesTransformStream extends TransformStream {
                             id: uuidv7(),
                             status: "in_progress",
                             summary: [],
+                            content: [],
                         };
                         const providerMetadata = part.providerMetadata;
                         if (providerMetadata) {
                             reasoningItem.extra_content = providerMetadata;
-                            const { redactedData } = extractReasoningMetadata(providerMetadata);
+                            const { redactedData, signature } = extractReasoningMetadata(providerMetadata);
                             if (redactedData) {
                                 reasoningItem.encrypted_content = redactedData;
                             }
+                            if (signature) {
+                                reasoningItem.signature = signature;
+                            }
                         }
                         reasoningOutputIndex = outputIndex++;
+                        reasoningContentIndex = 0;
                         outputItems.push(reasoningItem);
                         controller.enqueue({
                             event: "response.output_item.added",
@@ -834,14 +871,17 @@ export class ResponsesTransformStream extends TransformStream {
                                     id: reasoningItem.id,
                                     status: "in_progress",
                                     summary: [],
+                                    content: [],
                                     extra_content: reasoningItem.extra_content,
                                     encrypted_content: reasoningItem.encrypted_content,
+                                    signature: reasoningItem.signature,
                                 },
                             },
                         });
                         break;
                     }
                     case "reasoning-delta": {
+                        // Summary deltas
                         if (summaryIndex === reasoningItem.summary.length) {
                             const summaryPart = {
                                 type: "summary_text",
@@ -873,6 +913,26 @@ export class ResponsesTransformStream extends TransformStream {
                                 delta: part.text,
                             },
                         });
+                        // Content deltas (parallel to summary)
+                        const contentArr = reasoningItem.content;
+                        if (reasoningContentIndex === contentArr.length) {
+                            const contentPart = {
+                                type: "reasoning_text",
+                                text: "",
+                            };
+                            contentArr.push(contentPart);
+                        }
+                        contentArr[reasoningContentIndex].text += part.text;
+                        controller.enqueue({
+                            event: "response.reasoning_text.delta",
+                            data: {
+                                type: "response.reasoning_text.delta",
+                                item_id: reasoningItem.id,
+                                output_index: reasoningOutputIndex,
+                                content_index: reasoningContentIndex,
+                                delta: part.text,
+                            },
+                        });
                         break;
                     }
                     case "reasoning-end": {

package/dist/endpoints/responses/handler.js

@@ -54,14 +54,14 @@ export const responses = (config) => {
         ctx.resolvedProviderId = languageModel.provider;
         logger.debug(`[responses] using ${languageModel.provider} for ${ctx.resolvedModelId}`);
         addSpanEvent("hebo.provider.resolved");
-        const genAiSignalLevel = cfg.telemetry?.signals?.gen_ai;
-        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, genAiSignalLevel);
+        ctx.trace ??= ctx.body.trace ?? cfg.telemetry?.signals?.gen_ai;
+        const genAiGeneralAttrs = getGenAiGeneralAttributes(ctx, ctx.trace);
         setSpanAttributes(genAiGeneralAttrs);
-        const { model: _model, stream, ...inputs } = ctx.body;
+        const { model: _model, stream, trace: _trace, ...inputs } = ctx.body;
         const textOptions = convertToTextCallOptions(inputs);
         logger.trace({ requestId: ctx.requestId, options: textOptions }, "[responses] AI SDK options");
         addSpanEvent("hebo.options.prepared");
-        setSpanAttributes(getResponsesRequestAttributes(ctx.body, genAiSignalLevel));
+        setSpanAttributes(getResponsesRequestAttributes(ctx.body, ctx.trace));
         const languageModelWithMiddleware = wrapLanguageModel({
             model: languageModel,
             middleware: modelMiddlewareMatcher.for(ctx.resolvedModelId, languageModel.provider),
@@ -83,7 +83,7 @@ export const responses = (config) => {
                 onChunk: () => {
                     if (!ttft) {
                         ttft = performance.now() - start;
-                        recordTimeToFirstToken(ttft, genAiGeneralAttrs, genAiSignalLevel);
+                        recordTimeToFirstToken(ttft, genAiGeneralAttrs, ctx.trace);
                     }
                 },
                 onFinish: (res) => {
@@ -91,10 +91,10 @@ export const responses = (config) => {
                     const streamResult = toResponses(res, ctx.resolvedModelId, ctx.body.metadata);
                     logger.trace({ requestId: ctx.requestId, result: streamResult }, "[responses] Responses");
                     addSpanEvent("hebo.result.transformed");
-                    const genAiResponseAttrs = getResponsesResponseAttributes(streamResult, genAiSignalLevel, res.finishReason);
+                    const genAiResponseAttrs = getResponsesResponseAttributes(streamResult, ctx.trace, res.finishReason);
                     setSpanAttributes(genAiResponseAttrs);
-                    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
-                    recordTimePerOutputToken(start, ttft, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+                    recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
+                    recordTimePerOutputToken(start, ttft, genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
                 },
                 experimental_include: {
                     requestBody: false,
@@ -123,18 +123,18 @@ export const responses = (config) => {
         });
         logger.trace({ requestId: ctx.requestId, result }, "[responses] AI SDK result");
         addSpanEvent("hebo.ai-sdk.completed");
-        recordTimeToFirstToken(performance.now() - start, genAiGeneralAttrs, genAiSignalLevel);
+        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");
         addSpanEvent("hebo.result.transformed");
-        const genAiResponseAttrs = getResponsesResponseAttributes(ctx.result, genAiSignalLevel, result.finishReason);
+        const genAiResponseAttrs = getResponsesResponseAttributes(ctx.result, ctx.trace, result.finishReason);
         setSpanAttributes(genAiResponseAttrs);
-        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordTokenUsage(genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
         if (hooks?.after) {
             ctx.result = (await hooks.after(ctx)) ?? ctx.result;
             addSpanEvent("hebo.hooks.after.completed");
         }
-        recordTimePerOutputToken(start, 0, genAiResponseAttrs, genAiGeneralAttrs, genAiSignalLevel);
+        recordTimePerOutputToken(start, 0, genAiResponseAttrs, genAiGeneralAttrs, ctx.trace);
         return ctx.result;
     };
     return { handler: winterCgHandler(handler, config) };

package/dist/endpoints/responses/schema.d.ts

@@ -554,6 +554,7 @@ export declare const ResponsesReasoningItemSchema: z.ZodObject<{
         incomplete: "incomplete";
     }>>;
     extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+    signature: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ResponsesReasoningItem = z.infer<typeof ResponsesReasoningItemSchema>;
 /**
@@ -956,6 +957,7 @@ export declare const ResponsesInputItemSchema: z.ZodDiscriminatedUnion<[z.ZodDis
         incomplete: "incomplete";
     }>>;
     extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+    signature: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "type">;
 export type ResponsesInputItem = z.infer<typeof ResponsesInputItemSchema>;
 import { CacheControlSchema as ResponsesCacheControlSchema, ReasoningEffortSchema as ResponsesReasoningEffortSchema, ReasoningConfigSchema as ResponsesReasoningConfigSchema, ServiceTierSchema as ResponsesServiceTierSchema, ProviderMetadataSchema as ResponsesProviderMetadataSchema, type CacheControl as ResponsesCacheControl, type ReasoningEffort as ResponsesReasoningEffort, type ReasoningConfig as ResponsesReasoningConfig, type ServiceTier as ResponsesServiceTier, type ProviderMetadata as ResponsesProviderMetadata, ContentPartAudioSchema as ResponsesInputAudioSchema, type ContentPartAudio as ResponsesInputAudio } from "../shared/schema";
@@ -1429,6 +1431,7 @@ declare const ResponsesInputsSchema: z.ZodObject<{
             incomplete: "incomplete";
         }>>;
         extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+        signature: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "type">>]>;
     instructions: z.ZodOptional<z.ZodString>;
     tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -1923,6 +1926,7 @@ export declare const ResponsesBodySchema: z.ZodObject<{
             incomplete: "incomplete";
         }>>;
         extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+        signature: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "type">>]>;
     instructions: z.ZodOptional<z.ZodString>;
     tools: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -2019,6 +2023,12 @@ export declare const ResponsesBodySchema: z.ZodObject<{
     extra_body: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
     model: z.ZodString;
     stream: z.ZodOptional<z.ZodBoolean>;
+    trace: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodBoolean, z.ZodTransform<"off" | undefined, boolean>>, z.ZodEnum<{
+        off: "off";
+        required: "required";
+        recommended: "recommended";
+        full: "full";
+    }>]>>;
 }, z.core.$strip>;
 export type ResponsesBody = z.infer<typeof ResponsesBodySchema>;
 /**
@@ -2094,6 +2104,7 @@ export declare const ResponsesOutputItemSchema: z.ZodDiscriminatedUnion<[z.ZodOb
         incomplete: "incomplete";
     }>>;
     extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+    signature: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>], "type">;
 export type ResponsesOutputItem = z.infer<typeof ResponsesOutputItemSchema>;
 /**
@@ -2184,6 +2195,7 @@ export declare const ResponsesSchema: z.ZodObject<{
             incomplete: "incomplete";
         }>>;
         extra_content: z.ZodOptional<z.ZodType<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown, z.core.$ZodTypeInternals<import("@ai-sdk/provider").SharedV3ProviderMetadata, unknown>>>;
+        signature: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>], "type">>;
     usage: z.ZodNullable<z.ZodObject<{
         input_tokens: z.ZodNumber;
@@ -2270,6 +2282,20 @@ export type ResponseReasoningSummaryPartDoneEvent = SseFrame<{
     summary_index: number;
     part: ResponsesSummaryText;
 }, "response.reasoning_summary_part.done">;
+export type ResponseReasoningTextDeltaEvent = SseFrame<{
+    type: "response.reasoning_text.delta";
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    delta: string;
+}, "response.reasoning_text.delta">;
+export type ResponseReasoningTextDoneEvent = SseFrame<{
+    type: "response.reasoning_text.done";
+    item_id: string;
+    output_index: number;
+    content_index: number;
+    text: string;
+}, "response.reasoning_text.done">;
 export type ResponseOutputItemDoneEvent = SseFrame<{
     type: "response.output_item.done";
     output_index: number;
@@ -2297,5 +2323,5 @@ export type ResponseFailedEvent = SseFrame<{
     type: "response.failed";
     response: Responses;
 }, "response.failed">;
-export type ResponsesStreamEvent = ResponseCreatedEvent | ResponseInProgressEvent | ResponseOutputItemAddedEvent | ResponseContentPartAddedEvent | ResponseReasoningSummaryPartAddedEvent | ResponseOutputTextDeltaEvent | ResponseReasoningSummaryTextDeltaEvent | ResponseContentPartDoneEvent | ResponseReasoningSummaryPartDoneEvent | ResponseOutputItemDoneEvent | ResponseFunctionCallArgumentsDeltaEvent | ResponseFunctionCallArgumentsDoneEvent | ResponseCompletedEvent | ResponseFailedEvent;
+export type ResponsesStreamEvent = ResponseCreatedEvent | ResponseInProgressEvent | ResponseOutputItemAddedEvent | ResponseContentPartAddedEvent | ResponseReasoningSummaryPartAddedEvent | ResponseOutputTextDeltaEvent | ResponseReasoningSummaryTextDeltaEvent | ResponseReasoningTextDeltaEvent | ResponseContentPartDoneEvent | ResponseReasoningSummaryPartDoneEvent | ResponseReasoningTextDoneEvent | ResponseOutputItemDoneEvent | ResponseFunctionCallArgumentsDeltaEvent | ResponseFunctionCallArgumentsDoneEvent | ResponseCompletedEvent | ResponseFailedEvent;
 export type ResponsesStream = ReadableStream<ResponsesStreamEvent | SseErrorFrame>;

package/dist/endpoints/responses/schema.js

@@ -147,6 +147,8 @@ export const ResponsesReasoningItemSchema = z.object({
     status: ResponsesItemStatusSchema.optional(),
     // Extension origin: Gemini
     extra_content: ResponsesProviderMetadataSchema.optional().meta({ extension: true }),
+    // Extension origin: Anthropic/OpenRouter
+    signature: z.string().optional().meta({ extension: true }),
 });
 /**
  * --- Input Items ---
@@ -157,7 +159,7 @@ export const ResponsesInputItemSchema = z.discriminatedUnion("type", [
     ResponsesFunctionCallOutputSchema,
     ResponsesReasoningItemSchema,
 ]);
-import { CacheControlSchema as ResponsesCacheControlSchema, ReasoningEffortSchema as ResponsesReasoningEffortSchema, ReasoningConfigSchema as ResponsesReasoningConfigSchema, ServiceTierSchema as ResponsesServiceTierSchema, ProviderMetadataSchema as ResponsesProviderMetadataSchema, ContentPartAudioSchema as ResponsesInputAudioSchema, } from "../shared/schema";
+import { CacheControlSchema as ResponsesCacheControlSchema, ReasoningEffortSchema as ResponsesReasoningEffortSchema, ReasoningConfigSchema as ResponsesReasoningConfigSchema, ServiceTierSchema as ResponsesServiceTierSchema, ProviderMetadataSchema as ResponsesProviderMetadataSchema, ContentPartAudioSchema as ResponsesInputAudioSchema, TraceSchema, } from "../shared/schema";
 export { ResponsesCacheControlSchema, ResponsesReasoningEffortSchema, ResponsesReasoningConfigSchema, ResponsesServiceTierSchema, ResponsesProviderMetadataSchema, ResponsesInputAudioSchema, };
 /**
  * --- Tools ---
@@ -251,6 +253,7 @@ const ResponsesInputsSchema = z.object({
 export const ResponsesBodySchema = z.object({
     model: z.string(),
     stream: z.boolean().optional(),
+    trace: TraceSchema,
     ...ResponsesInputsSchema.shape,
 });
 /**

package/dist/endpoints/shared/schema.d.ts

@@ -61,6 +61,16 @@ export declare const ServiceTierSchema: z.ZodEnum<{
     priority: "priority";
 }>;
 export type ServiceTier = z.infer<typeof ServiceTierSchema>;
+/**
+ * Per-request trace control.
+ * Accepts a boolean (`false` → "off", `true` → stripped) or a signal level string.
+ */
+export declare const TraceSchema: z.ZodOptional<z.ZodUnion<readonly [z.ZodPipe<z.ZodBoolean, z.ZodTransform<"off" | undefined, boolean>>, z.ZodEnum<{
+    off: "off";
+    required: "required";
+    recommended: "recommended";
+    full: "full";
+}>]>>;
 export declare const ContentPartAudioSchema: z.ZodObject<{
     type: z.ZodLiteral<"input_audio">;
     input_audio: z.ZodObject<{

package/dist/endpoints/shared/schema.js

@@ -40,6 +40,16 @@ const InputAudioSchema = z.object({
     // https://docs.cloud.google.com/vertex-ai/generative-ai/docs/multimodal/audio-understanding
     format: InputAudioFormatSchema,
 });
+/**
+ * Per-request trace control.
+ * Accepts a boolean (`false` → "off", `true` → stripped) or a signal level string.
+ */
+export const TraceSchema = z
+    .union([
+    z.boolean().transform((v) => (v ? undefined : "off")),
+    z.enum(["off", "required", "recommended", "full"]),
+])
+    .optional();
 export const ContentPartAudioSchema = z.object({
     type: z.literal("input_audio"),
     input_audio: InputAudioSchema,

package/dist/errors/anthropic.d.ts

@@ -1,9 +1,14 @@
+import * as z from "zod";
+export declare const AnthropicErrorSchema: z.ZodObject<{
+    type: z.ZodLiteral<"error">;
+    error: z.ZodObject<{
+        type: z.ZodString;
+        message: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
 export declare class AnthropicError {
-    readonly type = "error";
-    readonly error: {
-        type: string;
-        message: string;
-    };
+    readonly type: "error";
+    readonly error: z.infer<typeof AnthropicErrorSchema>["error"];
     constructor(message: string, type?: string);
 }
 export declare function toAnthropicError(error: unknown): AnthropicError;

package/dist/errors/anthropic.js

@@ -1,6 +1,14 @@
+import * as z from "zod";
 import { resolveRequestId } from "../utils/headers";
 import { toResponse } from "../utils/response";
 import { getErrorMeta, maybeMaskMessage } from "./utils";
+export const AnthropicErrorSchema = z.object({
+    type: z.literal("error"),
+    error: z.object({
+        type: z.string(),
+        message: z.string(),
+    }),
+});
 export class AnthropicError {
     type = "error";
     error;

package/dist/lifecycle.js

@@ -60,7 +60,7 @@ export const winterCgHandler = (run, config) => {
                 ctx.operation === "embeddings" ||
                 ctx.operation === "messages" ||
                 ctx.operation === "responses") {
-                recordRequestDuration(performance.now() - start, realStatus, ctx, parsedConfig.telemetry?.signals?.gen_ai);
+                recordRequestDuration(performance.now() - start, realStatus, ctx, ctx.trace ?? parsedConfig.telemetry?.signals?.gen_ai);
             }
             span.finish();
         };

package/dist/providers/bedrock/middleware.js

@@ -78,7 +78,7 @@ export const bedrockClaudeReasoningMiddleware = {
                 // "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";
+                const mappedEffort = effort === "max" ? "xhigh" : (effort ?? "medium");
                 target.budgetTokens = calculateReasoningBudgetFromEffort(mappedEffort, params.maxOutputTokens ?? 65536, 1024);
             }
         }

package/dist/types.d.ts

@@ -71,6 +71,12 @@ export type GatewayContext = {
      * Response object returned by the handler.
      */
     response?: Response;
+    /**
+     * Per-request telemetry signal level override.
+     * When set (via body parameter or hook), overrides `cfg.telemetry.signals.gen_ai`
+     * for this request's span attributes and metrics.
+     */
+    trace?: TelemetrySignalLevel;
     /**
      * Error thrown during execution.
      */
@@ -79,9 +85,10 @@ export type GatewayContext = {
 /**
  * Hook context: all fields readonly except `state` and `otel`.
  */
-export type HookContext = Omit<Readonly<GatewayContext>, "state" | "otel"> & {
+export type HookContext = Omit<Readonly<GatewayContext>, "state" | "otel" | "trace"> & {
     state: GatewayContext["state"];
     otel: GatewayContext["otel"];
+    trace: GatewayContext["trace"];
 };
 type RequiredHookContext<K extends keyof GatewayContext> = Omit<HookContext, K> & Required<Pick<HookContext, K>>;
 export type OnRequestHookContext = RequiredHookContext<"request">;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hebo-ai/gateway",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "description": "AI gateway as a framework. For full control over models, routing & lifecycle. OpenAI /chat/completions, OpenResponses /responses & Anthropic /messages.",
   "keywords": [
     "ai",
@@ -208,6 +208,7 @@
     "lefthook": "^2.1.5",
     "mysql2": "^3.21.0",
     "next": "^16.2.3",
+    "openai": "^6.34.0",
     "oxfmt": "^0.44.0",
     "oxlint": "^1.59.0",
     "oxlint-tsgolint": "^0.20.0",