omnigateway 0.7.1 → 0.7.2

package/gateway.js

@@ -6879,6 +6879,10 @@ class GatewayError extends Error {
 }
 // packages/ir/src/logger.ts
 var LEVELS = { debug: 10, info: 20, warn: 30, error: 40 };
+function safeToken(value) {
+  const text = typeof value === "string" ? value : String(value);
+  return /^[A-Za-z0-9_.:/+-]{1,64}$/.test(text) ? text : "(unprintable)";
+}
 var FIELD_ORDER = [
   "requestId",
   "surface",
@@ -6916,6 +6920,12 @@ var FIELD_ORDER = [
   "reason"
 ];
 var REASON_MAX = 200;
+var MODEL_MAX = 120;
+var CAPS = {
+  reason: REASON_MAX,
+  model: MODEL_MAX,
+  requestedModel: MODEL_MAX
+};
 var LEVEL_COLOR = {
   debug: "\x1B[2;37m",
   info: "\x1B[36m",
@@ -6941,7 +6951,8 @@ function formatLine(level, at, msg, fields, color) {
     const value = fields[key];
     if (value === undefined)
       continue;
-    const capped = key === "reason" && typeof value === "string" && value.length > REASON_MAX ? `${value.slice(0, REASON_MAX)}\u2026` : value;
+    const cap = CAPS[key];
+    const capped = cap !== undefined && typeof value === "string" && value.length > cap ? `${value.slice(0, cap)}\u2026` : value;
     parts.push(`${key}=${renderValue(capped)}`);
   }
   return parts.length === 0 ? head : `${head}  ${parts.join(" ")}`;
@@ -26110,10 +26121,10 @@ function toCustomResponsesWire(req, model) {
     note("custom:context-1m-dropped");
   for (const message of req.messages) {
     const parts = [];
-    const inlined = message.role === "system";
-    if (inlined)
-      note("custom:system-turn-inlined");
-    const role = inlined ? "user" : message.role;
+    const asDeveloper = message.role === "system";
+    if (asDeveloper)
+      note("custom:system-turn-as-developer");
+    const role = asDeveloper ? "developer" : message.role;
     const flush = () => {
       if (parts.length === 0)
         return;
@@ -26125,9 +26136,7 @@ function toCustomResponsesWire(req, model) {
         case "text":
           parts.push({
             type: role === "assistant" ? "output_text" : "input_text",
-            text: inlined ? `<system-reminder>
-${block.text}
-</system-reminder>` : block.text
+            text: block.text
           });
           break;
         case "image":
@@ -26205,7 +26214,7 @@ function metadata(data, fail) {
 function endpointUrl(origin, basePath, protocol) {
   const suffix = protocol === "chat_completions" ? "chat/completions" : "responses";
   const base = `${origin}${basePath}`.replace(/\/+$/, "");
-  return base.endsWith("/v1") ? `${base}/${suffix}` : `${base}/v1/${suffix}`;
+  return /\/v\d+$/i.test(base) ? `${base}/${suffix}` : `${base}/v1/${suffix}`;
 }
 function protocolOf(state, fail) {
   if (state !== null && typeof state === "object") {
@@ -26474,10 +26483,10 @@ function toGrokWire(req, model) {
     note("grok:context-1m-dropped");
   for (const message of req.messages) {
     const parts = [];
-    const inlined = message.role === "system";
-    if (inlined)
-      note("grok:system-turn-inlined");
-    const role = inlined ? "user" : message.role;
+    const asDeveloper = message.role === "system";
+    if (asDeveloper)
+      note("grok:system-turn-as-developer");
+    const role = asDeveloper ? "developer" : message.role;
     const flush = () => {
       if (parts.length === 0)
         return;
@@ -26489,9 +26498,7 @@ function toGrokWire(req, model) {
         case "text":
           parts.push({
             type: role === "assistant" ? "output_text" : "input_text",
-            text: inlined ? `<system-reminder>
-${block.text}
-</system-reminder>` : block.text
+            text: block.text
           });
           break;
         case "image":
@@ -27283,6 +27290,7 @@ var ERROR_CODE2 = {
   content_policy_violation: "CONTENT_FILTER"
 };
 var KNOWN_EVENTS3 = new Set([
+  "keepalive",
   "response.created",
   "response.queued",
   "response.in_progress",
@@ -27316,7 +27324,8 @@ function json7(data) {
     return null;
   }
 }
-async function* decodeResponses(messages) {
+async function* decodeResponses(messages, options = {}) {
+  const nativeReasoning = options.nativeReasoning === true;
   const indices = new Map;
   let next = 0;
   const irIndex = (outputIndex, contentIndex = 0) => {
@@ -27361,7 +27370,7 @@ async function* decodeResponses(messages) {
           yield {
             type: "blockStart",
             index: irIndex(d.output_index ?? 0),
-            block: { type: "thinking" }
+            block: nativeReasoning ? { type: "providerNative", provider: "openai", blockType: "reasoning", data: {} } : { type: "thinking" }
           };
         } else if (item.type === "function_call") {
           sawToolCall = true;
@@ -27394,7 +27403,12 @@ async function* decodeResponses(messages) {
         yield {
           type: "blockDelta",
           index: irIndex(d.output_index ?? 0),
-          delta: { type: "thinking", text: String(d.delta ?? "") }
+          delta: nativeReasoning ? {
+            type: "providerNative",
+            provider: "openai",
+            deltaType: "reasoning_summary_text.delta",
+            data: { text: String(d.delta ?? "") }
+          } : { type: "thinking", text: String(d.delta ?? "") }
         };
         break;
       case "response.function_call_arguments.delta":
@@ -27410,6 +27424,20 @@ async function* decodeResponses(messages) {
       case "response.output_item.done": {
         const outputIndex = d.output_index ?? 0;
         if (ownsBlock.delete(outputIndex)) {
+          const item = d.item ?? {};
+          if (nativeReasoning && item.type === "reasoning") {
+            yield {
+              type: "blockDelta",
+              index: irIndex(outputIndex),
+              delta: {
+                type: "providerNative",
+                provider: "openai",
+                deltaType: "response.output_item.done",
+                fold: "merge",
+                data: item
+              }
+            };
+          }
           yield { type: "blockEnd", index: irIndex(outputIndex) };
         }
         break;
@@ -27483,6 +27511,23 @@ function cacheKey(req, instructions, firstInput) {
   const stable = req.conversationId !== undefined && req.conversationId.length > 0 ? JSON.stringify({ conversation: req.conversationId }) : JSON.stringify({ instructions, firstInput: firstInput ?? null });
   return createHash3("sha256").update(stable).digest("hex").slice(0, 32);
 }
+function repairOrphanedCalls(input) {
+  const answered = new Set;
+  for (const item of input) {
+    const record2 = item;
+    if (record2.type === "function_call_output" && typeof record2.call_id === "string") {
+      answered.add(record2.call_id);
+    }
+  }
+  for (let i = input.length - 1;i >= 0; i--) {
+    const record2 = input[i];
+    if (record2.type !== "function_call" || typeof record2.call_id !== "string")
+      continue;
+    if (answered.has(record2.call_id))
+      continue;
+    input.splice(i + 1, 0, { type: "function_call_output", call_id: record2.call_id, output: "" });
+  }
+}
 function encodeToolChoice5(c) {
   switch (c.type) {
     case "auto":
@@ -27506,10 +27551,10 @@ function toResponsesWire(req, model, opts = { oauth: false }) {
     note("openai:context-1m-dropped");
   for (const message of req.messages) {
     const parts = [];
-    const inlined = message.role === "system";
-    if (inlined)
-      note("openai:system-turn-inlined");
-    const role = inlined ? "user" : message.role;
+    const asDeveloper = message.role === "system";
+    if (asDeveloper)
+      note("openai:system-turn-as-developer");
+    const role = asDeveloper ? "developer" : message.role;
     const flush = () => {
       if (parts.length === 0)
         return;
@@ -27521,9 +27566,7 @@ function toResponsesWire(req, model, opts = { oauth: false }) {
         case "text":
           parts.push({
             type: role === "assistant" ? "output_text" : "input_text",
-            text: inlined ? `<system-reminder>
-${block.text}
-</system-reminder>` : block.text
+            text: block.text
           });
           break;
         case "image":
@@ -27555,12 +27598,19 @@ ${block.text}
           });
           break;
         case "providerNative":
+          if (block.provider === "openai") {
+            flush();
+            const { id: _id, ...rest } = block.data;
+            input.push({ type: block.blockType, ...rest });
+            break;
+          }
           note("openai:anthropic-native-block-dropped");
           break;
       }
     }
     flush();
   }
+  repairOrphanedCalls(input);
   const body = { model, input, stream: req.stream, store: false };
   const instructions = systemText(req.system, "openai", note);
   if (instructions !== undefined && instructions.length > 0)
@@ -27624,7 +27674,10 @@ var openaiCodec = {
       throw input.fail("AUTH", "openai credential has no token");
     }
     const headers = orderHeaders(mergeHeaders(openaiProfile.headers, protocol), openaiProfile.order);
+    const include = body.include;
+    const nativeReasoning = Array.isArray(include) && include.includes("reasoning.encrypted_content");
     return {
+      decodeState: { nativeReasoning },
       request: {
         url: oauth ? OAUTH_URL2 : API_URL3,
         method: "POST",
@@ -27634,8 +27687,9 @@ var openaiCodec = {
       degradations
     };
   },
-  decode({ body }) {
-    return decodeResponses(parseSse(body));
+  decode({ body, decodeState }) {
+    const state = decodeState;
+    return decodeResponses(parseSse(body), { nativeReasoning: state?.nativeReasoning === true });
   }
 };
 
@@ -27819,8 +27873,10 @@ function parseOrThrow(schema, body2) {
   if (result.success)
     return result.data;
   const issue2 = result.error.issues[0];
-  const path = issue2?.path.join(".") ?? "(root)";
-  throw new GatewayError("BAD_REQUEST", `${path}: ${issue2?.message ?? "invalid request"}`);
+  const segments = issue2?.path ?? [];
+  const path = segments.length === 0 ? "(root)" : segments.map((s) => safeToken(String(s))).join(".");
+  const detail = issue2 === undefined ? "invalid request" : issue2.code === "unrecognized_keys" ? `unrecognized key "${safeToken(issue2.keys[0])}"` : issue2.message;
+  throw new GatewayError("BAD_REQUEST", `${path}: ${detail}`);
 }
 function optionalNumber(value, fallback) {
   if (value === undefined)
@@ -28326,13 +28382,13 @@ function resolveModel(name, snapshot, providers = PROVIDER_DESCRIPTORS) {
     if (descriptor2 !== undefined && prefix !== "custom" && rest.length > 0) {
       return synthesize(prefix, rest, descriptor2);
     }
-    throw new GatewayError("NO_CANDIDATES", `unknown provider "${prefix}" in model "${name}"`);
+    throw new GatewayError("NO_CANDIDATES", `unknown provider "${safeToken(prefix)}" in model "${safeToken(name)}"`);
   }
   for (const [prefix, provider, descriptor2] of prefixProviders(providers)) {
     if (name.startsWith(prefix))
       return synthesize(provider, name, descriptor2);
   }
-  throw new GatewayError("NO_CANDIDATES", `model "${name}" is not a configured virtual model and its provider could not be inferred`);
+  throw new GatewayError("NO_CANDIDATES", `model "${safeToken(name)}" is not a configured virtual model and its provider could not be inferred`);
 }
 
 // packages/router/src/index.ts
@@ -45483,6 +45539,367 @@ function openaiRateLimitHeaders(headroom, now) {
   return headers;
 }
 
+// apps/gateway/src/egress/responses.ts
+var STATUS = {
+  endTurn: { status: "completed" },
+  toolUse: { status: "completed" },
+  stopSequence: { status: "completed" },
+  pauseTurn: { status: "completed" },
+  maxTokens: { status: "incomplete", reason: "max_output_tokens" },
+  contentFilter: { status: "incomplete", reason: "content_filter" }
+};
+function usageBody2(usage) {
+  const input = promptTokens(usage);
+  return {
+    input_tokens: input,
+    input_tokens_details: { cached_tokens: usage.cacheReadTokens },
+    output_tokens: usage.outputTokens,
+    output_tokens_details: { reasoning_tokens: 0 },
+    total_tokens: input + usage.outputTokens
+  };
+}
+var CONTENT_INDEX = 0;
+function customToolInput(raw) {
+  try {
+    const parsed2 = JSON.parse(raw);
+    if (typeof parsed2 === "object" && parsed2 !== null && "input" in parsed2) {
+      const inner = parsed2.input;
+      if (typeof inner === "string")
+        return inner;
+    }
+  } catch {}
+  return raw;
+}
+function renderItem(item, status2) {
+  const done = status2 === "completed";
+  switch (item.kind) {
+    case "message":
+      return {
+        id: item.id,
+        type: "message",
+        status: status2,
+        role: "assistant",
+        content: done ? [{ type: "output_text", text: item.text, annotations: [] }] : []
+      };
+    case "reasoning":
+      return {
+        id: item.id,
+        type: "reasoning",
+        status: status2,
+        summary: done && item.text !== "" ? [{ type: "summary_text", text: item.text }] : []
+      };
+    case "function_call":
+      return {
+        id: item.id,
+        type: "function_call",
+        status: status2,
+        call_id: item.callId,
+        name: item.toolName,
+        arguments: done ? item.text : ""
+      };
+    case "custom_tool_call":
+      return {
+        id: item.id,
+        type: "custom_tool_call",
+        status: status2,
+        call_id: item.callId,
+        name: item.toolName,
+        input: done ? customToolInput(item.text) : ""
+      };
+    case "native":
+      return item.native;
+  }
+}
+async function* responsesStream(events, render) {
+  let model = "";
+  let sequence = 0;
+  let terminated = false;
+  const frame2 = (event, data) => ({
+    event,
+    data: JSON.stringify({ type: event, sequence_number: ++sequence, ...data })
+  });
+  const output = [];
+  const snapshot = (status2, extra) => ({
+    id: `resp_${render.requestId}`,
+    object: "response",
+    created_at: render.created,
+    status: status2,
+    model,
+    output,
+    ...extra
+  });
+  let nextOutputIndex = 0;
+  const state = { open: null };
+  const ID_PREFIX = {
+    message: "msg",
+    reasoning: "rs",
+    function_call: "fc",
+    custom_tool_call: "ctc",
+    native: "item"
+  };
+  const open = (irIndex, kind, seed) => {
+    const outputIndex = nextOutputIndex++;
+    const id = seed?.callId !== undefined && seed.callId !== "" ? `${ID_PREFIX[kind]}_${seed.callId}` : `${ID_PREFIX[kind]}_${render.requestId}_${outputIndex}`;
+    state.open = {
+      irIndex,
+      outputIndex,
+      id,
+      kind,
+      text: "",
+      toolName: "",
+      callId: "",
+      native: {},
+      ...seed
+    };
+    return state.open;
+  };
+  const itemBody = (item, status2) => renderItem(item, status2);
+  function* closeCurrent() {
+    const item = state.open;
+    if (item === null)
+      return;
+    state.open = null;
+    const at = { item_id: item.id, output_index: item.outputIndex, content_index: CONTENT_INDEX };
+    switch (item.kind) {
+      case "message":
+        yield frame2("response.output_text.done", { ...at, text: item.text });
+        yield frame2("response.content_part.done", {
+          ...at,
+          part: { type: "output_text", text: item.text, annotations: [] }
+        });
+        break;
+      case "reasoning":
+        yield frame2("response.reasoning_summary_text.done", {
+          item_id: item.id,
+          output_index: item.outputIndex,
+          summary_index: CONTENT_INDEX,
+          text: item.text
+        });
+        yield frame2("response.reasoning_summary_part.done", {
+          item_id: item.id,
+          output_index: item.outputIndex,
+          summary_index: CONTENT_INDEX,
+          part: { type: "summary_text", text: item.text }
+        });
+        break;
+      case "function_call":
+        yield frame2("response.function_call_arguments.done", {
+          item_id: item.id,
+          output_index: item.outputIndex,
+          arguments: item.text
+        });
+        break;
+      case "custom_tool_call": {
+        const input = customToolInput(item.text);
+        yield frame2("response.custom_tool_call_input.delta", {
+          item_id: item.id,
+          output_index: item.outputIndex,
+          delta: input
+        });
+        yield frame2("response.custom_tool_call_input.done", {
+          item_id: item.id,
+          output_index: item.outputIndex,
+          input
+        });
+        break;
+      }
+      case "native":
+        break;
+    }
+    const body2 = itemBody(item, "completed");
+    output.push(body2);
+    yield frame2("response.output_item.done", { output_index: item.outputIndex, item: body2 });
+  }
+  function* closeChecked(irIndex) {
+    if (state.open === null || state.open.irIndex !== irIndex)
+      return;
+    yield* closeCurrent();
+  }
+  for await (const event of events) {
+    switch (event.type) {
+      case "start":
+        model = event.model;
+        yield frame2("response.created", { response: snapshot("in_progress") });
+        yield frame2("response.in_progress", { response: snapshot("in_progress") });
+        break;
+      case "blockStart": {
+        if (state.open !== null && state.open.irIndex === event.index)
+          break;
+        yield* closeCurrent();
+        const block = event.block;
+        const kind = block.type === "text" ? "message" : block.type === "thinking" ? "reasoning" : block.type === "toolUse" ? render.customToolNames.has(block.name) ? "custom_tool_call" : "function_call" : "native";
+        const item = open(event.index, kind, block.type === "toolUse" ? { callId: block.id, toolName: block.name } : block.type === "providerNative" ? { native: { type: block.blockType, ...block.data } } : {});
+        yield frame2("response.output_item.added", {
+          output_index: item.outputIndex,
+          item: itemBody(item, "in_progress")
+        });
+        if (kind === "message") {
+          yield frame2("response.content_part.added", {
+            item_id: item.id,
+            output_index: item.outputIndex,
+            content_index: CONTENT_INDEX,
+            part: { type: "output_text", text: "", annotations: [] }
+          });
+        }
+        if (kind === "reasoning") {
+          yield frame2("response.reasoning_summary_part.added", {
+            item_id: item.id,
+            output_index: item.outputIndex,
+            summary_index: CONTENT_INDEX,
+            part: { type: "summary_text", text: "" }
+          });
+        }
+        break;
+      }
+      case "blockDelta": {
+        const item = state.open;
+        if (item === null || item.irIndex !== event.index)
+          break;
+        const delta2 = event.delta;
+        if (delta2.type === "text" && item.kind === "message") {
+          item.text += delta2.text;
+          yield frame2("response.output_text.delta", {
+            item_id: item.id,
+            output_index: item.outputIndex,
+            content_index: CONTENT_INDEX,
+            delta: delta2.text
+          });
+        }
+        if (delta2.type === "thinking" && item.kind === "reasoning") {
+          item.text += delta2.text;
+          yield frame2("response.reasoning_summary_text.delta", {
+            item_id: item.id,
+            output_index: item.outputIndex,
+            summary_index: CONTENT_INDEX,
+            delta: delta2.text
+          });
+        }
+        if (delta2.type === "toolJson") {
+          item.text += delta2.partial;
+          if (item.kind === "function_call") {
+            yield frame2("response.function_call_arguments.delta", {
+              item_id: item.id,
+              output_index: item.outputIndex,
+              delta: delta2.partial
+            });
+          }
+        }
+        if (delta2.type === "providerNative" && item.kind === "native") {
+          if (delta2.deltaType === "reasoning_summary_text.delta") {
+            yield frame2("response.reasoning_summary_text.delta", {
+              item_id: item.id,
+              output_index: item.outputIndex,
+              summary_index: CONTENT_INDEX,
+              delta: String(delta2.data.text ?? "")
+            });
+          }
+          if (delta2.fold === "merge") {
+            item.native = { ...item.native, ...delta2.data };
+          }
+        }
+        break;
+      }
+      case "blockEnd":
+        yield* closeChecked(event.index);
+        break;
+      case "end": {
+        yield* closeCurrent();
+        const { status: status2, reason } = STATUS[event.stopReason];
+        terminated = true;
+        yield frame2(status2 === "completed" ? "response.completed" : "response.incomplete", {
+          response: snapshot(status2, {
+            ...reason === undefined ? {} : { incomplete_details: { reason } },
+            usage: usageBody2(event.usage)
+          })
+        });
+        break;
+      }
+      case "error":
+        yield* closeCurrent();
+        terminated = true;
+        yield frame2("response.failed", {
+          response: snapshot("failed", {
+            error: { code: ERROR_TYPE3[event.code].code, message: event.message }
+          })
+        });
+        break;
+    }
+  }
+  if (!terminated) {
+    yield* closeCurrent();
+    yield frame2("response.failed", {
+      response: snapshot("failed", {
+        error: { code: "stream_disconnected", message: "stream closed before response.completed" }
+      })
+    });
+  }
+  yield { event: "message", data: "[DONE]" };
+}
+function responsesResponse(collected, render) {
+  const output = [];
+  let index = 0;
+  for (const block of collected.content) {
+    const outputIndex = index++;
+    const at = { irIndex: outputIndex, outputIndex, toolName: "", callId: "", native: {} };
+    if (block.type === "text") {
+      output.push(renderItem({
+        ...at,
+        kind: "message",
+        id: `msg_${render.requestId}_${outputIndex}`,
+        text: block.text
+      }, "completed"));
+    }
+    if (block.type === "thinking") {
+      output.push(renderItem({
+        ...at,
+        kind: "reasoning",
+        id: `rs_${render.requestId}_${outputIndex}`,
+        text: block.text
+      }, "completed"));
+    }
+    if (block.type === "toolUse") {
+      const custom2 = render.customToolNames.has(block.name);
+      const kind = custom2 ? "custom_tool_call" : "function_call";
+      output.push(renderItem({
+        ...at,
+        kind,
+        id: `${custom2 ? "ctc" : "fc"}_${block.id}`,
+        text: JSON.stringify(block.input),
+        toolName: block.name,
+        callId: block.id
+      }, "completed"));
+    }
+    if (block.type === "providerNative" && block.provider === "openai") {
+      output.push(renderItem({
+        ...at,
+        kind: "native",
+        id: `item_${render.requestId}_${outputIndex}`,
+        text: "",
+        native: { type: block.blockType, ...block.data }
+      }, "completed"));
+    }
+  }
+  const { status: status2, reason } = STATUS[collected.stopReason];
+  return {
+    id: `resp_${render.requestId}`,
+    object: "response",
+    created_at: render.created,
+    status: status2,
+    model: collected.model,
+    output,
+    store: false,
+    ...reason === undefined ? {} : { incomplete_details: { reason } },
+    usage: usageBody2(collected.usage)
+  };
+}
+function responsesErrorBody(code, message) {
+  const { type, code: errorCode } = ERROR_TYPE3[code];
+  return { error: { type, code: errorCode, message, param: null } };
+}
+function responsesRateLimitHeaders(headroom, now) {
+  return openaiRateLimitHeaders(headroom, now);
+}
+
 // apps/gateway/src/ingress/schemas.ts
 var cacheControlSchema = exports_external.object({
   type: exports_external.literal("ephemeral"),
@@ -45511,8 +45928,19 @@ function parseOrThrow2(schema, body2) {
   if (result.success)
     return result.data;
   const issue2 = result.error.issues[0];
-  const path = issue2?.path.join(".") ?? "(root)";
-  throw new GatewayError("BAD_REQUEST", `${path}: ${issue2?.message ?? "invalid request"}`);
+  throw new GatewayError("BAD_REQUEST", `${issuePath(issue2)}: ${zodDetail(issue2)}`);
+}
+function issuePath(issue2) {
+  const segments = issue2?.path ?? [];
+  return segments.length === 0 ? "(root)" : segments.map((s) => safeToken(String(s))).join(".");
+}
+function zodDetail(issue2) {
+  if (issue2 === undefined)
+    return "invalid request";
+  if (issue2.code === "unrecognized_keys") {
+    return `unrecognized key "${safeToken(issue2.keys[0])}"`;
+  }
+  return issue2.message;
 }
 function isRecord7(value) {
   return typeof value === "object" && value !== null;
@@ -45528,7 +45956,8 @@ function extraFields(body2, known) {
 var CONVERSATION_HEADERS = [
   "x-session-id",
   "x-session-affinity",
-  "x-deepseek-harness-session-id"
+  "x-deepseek-harness-session-id",
+  "session-id"
 ];
 function readConversationHeader(headers) {
   for (const name of CONVERSATION_HEADERS) {
@@ -45573,7 +46002,7 @@ function readSidecarImage(raw, declaredMediaType) {
     };
   }
   if (!mediaType.startsWith("image/")) {
-    return { ok: false, reason: "not-an-image", detail: `${mediaType} is not an image` };
+    return { ok: false, reason: "not-an-image", detail: `${safeToken(mediaType)} is not an image` };
   }
   return { ok: true, mediaType, data: resolved.data };
 }
@@ -48866,7 +49295,7 @@ async function dispatch(request2, deps, signal, requestId) {
   }
   if (candidates.length === 0) {
     clearDeadline();
-    return fail("NO_CANDIDATES", `no eligible credential for model "${request2.model}"`);
+    return fail("NO_CANDIDATES", `no eligible credential for model "${safeToken(request2.model)}"`);
   }
   const maxAttempts = Math.min(snapshot.settings.maxAttempts, candidates.length);
   const head = candidates[0];
@@ -48990,7 +49419,9 @@ async function dispatch(request2, deps, signal, requestId) {
                   if (event.type === "error") {
                     terminal = true;
                     if (!committed && RETRYABLE[event.code]) {
-                      throw new GatewayError(event.code, event.message);
+                      throw new GatewayError(event.code, event.message, {
+                        provider: candidate.target.provider
+                      });
                     }
                     committed = true;
                     log.status = HTTP_STATUS[event.code];
@@ -49266,18 +49697,18 @@ function fail(path, message) {
 }
 function field(path, name, value) {
   const schema = TOOL_FIELDS[name];
-  if (schema === undefined)
-    fail(`${path}.${name}`, `unsupported field "${name}"`);
-  const parsed2 = schema.safeParse(value);
-  if (!parsed2.success) {
-    fail(`${path}.${name}`, parsed2.error.issues[0]?.message ?? "invalid value");
+  if (schema === undefined) {
+    fail(`${path}.${safeToken(name)}`, `unsupported field "${safeToken(name)}"`);
   }
+  const parsed2 = schema.safeParse(value);
+  if (!parsed2.success)
+    fail(`${path}.${safeToken(name)}`, zodDetail(parsed2.error.issues[0]));
   return parsed2.data;
 }
 function parseAnthropicTool(raw, type, path, mcpServerNames) {
   const spec = anthropicToolSpec(type);
   if (spec === undefined)
-    fail(`${path}.type`, `unrecognized tool type "${type}"`);
+    fail(`${path}.type`, `unrecognized tool type "${safeToken(type)}"`);
   if (spec.name !== undefined && raw.name !== spec.name) {
     fail(`${path}.name`, `${type} must be declared with name "${spec.name}"`);
   }
@@ -49294,8 +49725,9 @@ function parseAnthropicTool(raw, type, path, mcpServerNames) {
   for (const [key, value] of Object.entries(raw)) {
     if (key === "type" || key === "name")
       continue;
-    if (!allowed.has(key))
-      fail(`${path}.${key}`, `${type} does not accept "${key}"`);
+    if (!allowed.has(key)) {
+      fail(`${path}.${safeToken(key)}`, `${type} does not accept "${safeToken(key)}"`);
+    }
     const parsed2 = field(path, key, value);
     if (key === "cache_control") {
       cacheControl = irCacheControl(parsed2 === null ? undefined : parsed2).cacheControl;
@@ -49310,7 +49742,7 @@ function parseAnthropicTool(raw, type, path, mcpServerNames) {
   if (spec.family === "mcpToolset") {
     const server = wire.mcp_server_name;
     if (typeof server === "string" && !mcpServerNames.has(server)) {
-      fail(`${path}.mcp_server_name`, `no mcp_servers entry named "${server}"`);
+      fail(`${path}.mcp_server_name`, `no mcp_servers entry named "${safeToken(server)}"`);
     }
   }
   return {
@@ -49334,7 +49766,7 @@ function parseCustomTool(raw, path) {
     if (["type", "name", "description", "input_schema", "cache_control"].includes(key))
       continue;
     if (!ANTHROPIC_CUSTOM_TOOL_OPTIONS.includes(key)) {
-      fail(`${path}.${key}`, `unsupported field "${key}"`);
+      fail(`${path}.${safeToken(key)}`, `unsupported field "${safeToken(key)}"`);
     }
     const value_ = field(path, key, value);
     if (value_ !== null)
@@ -49381,6 +49813,7 @@ function mcpServerNames(body2) {
 }
 
 // apps/gateway/src/ingress/model.ts
+var MODEL_NAME_MAX = 200;
 var ONE_M_SUFFIX2 = "[1m]";
 function normalizeClientModel(raw, betas2 = []) {
   let model = raw.trim();
@@ -49577,7 +50010,7 @@ var message = exports_external.object({
   content: exports_external.union([exports_external.string(), exports_external.array(exports_external.unknown())])
 });
 var schema = exports_external.object({
-  model: exports_external.string().min(1),
+  model: exports_external.string().min(1).max(MODEL_NAME_MAX),
   messages: exports_external.array(message).min(1),
   system: exports_external.union([exports_external.string(), exports_external.array(textBlock)]).optional(),
   max_tokens: exports_external.number().int().positive().optional(),
@@ -49701,9 +50134,10 @@ function readBlock(raw, role, path) {
       const parsed3 = nativeSchema.safeParse(raw);
       if (!parsed3.success) {
         const issue2 = parsed3.error.issues[0];
-        const issuePath = issue2?.code === "unrecognized_keys" ? [...issue2.path, issue2.keys[0]] : issue2?.path;
-        const suffix = issuePath?.length ? `.${issuePath.join(".")}` : "";
-        throw new GatewayError("BAD_REQUEST", `${path}${suffix}: ${issue2?.message ?? "invalid native content block"}`);
+        const unknownKey = issue2?.code === "unrecognized_keys" ? safeToken(issue2.keys[0]) : null;
+        const issuePath2 = unknownKey === null ? issue2?.path : [...issue2?.path ?? [], unknownKey];
+        const suffix = issuePath2?.length ? `.${issuePath2.join(".")}` : "";
+        throw new GatewayError("BAD_REQUEST", `${path}${suffix}: ${zodDetail(issue2)}`);
       }
       const { type: _type, cache_control, ...data } = parsed3.data;
       return {
@@ -49721,11 +50155,11 @@ function readBlock(raw, role, path) {
     if (issue2?.code === "invalid_union" || issue2?.path.at(-1) === "type") {
       const type = raw?.type;
       if (typeof type === "string") {
-        throw new GatewayError("BAD_REQUEST", `${path}.type: unrecognized block type "${type}"`);
+        throw new GatewayError("BAD_REQUEST", `${path}.type: unrecognized block type "${safeToken(type)}"`);
       }
     }
     const suffix = issue2?.path.length ? `.${issue2.path.join(".")}` : "";
-    throw new GatewayError("BAD_REQUEST", `${path}${suffix}: ${issue2?.message ?? "invalid content block"}`);
+    throw new GatewayError("BAD_REQUEST", `${path}${suffix}: ${zodDetail(issue2)}`);
   }
   return toIrBlock(parsed2.data);
 }
@@ -49872,7 +50306,7 @@ function sidecarImages(m) {
   return blocks2;
 }
 var schema2 = exports_external.object({
-  model: exports_external.string().min(1),
+  model: exports_external.string().min(1).max(MODEL_NAME_MAX),
   messages: exports_external.array(message2).min(1),
   max_tokens: exports_external.number().int().positive().optional(),
   max_completion_tokens: exports_external.number().int().positive().optional(),
@@ -50031,6 +50465,265 @@ function parseOpenAIRequest(body2, headers) {
   return validateRequest(request2);
 }
 
+// apps/gateway/src/ingress/responses.ts
+import { createHash as createHash4 } from "crypto";
+var reasoning = exports_external.object({
+  effort: exports_external.enum(REASONING_EFFORTS).optional(),
+  summary: exports_external.string().optional()
+});
+var schema3 = exports_external.object({
+  model: exports_external.string().min(1).max(MODEL_NAME_MAX),
+  input: exports_external.union([exports_external.string(), exports_external.array(exports_external.unknown())]),
+  tools: exports_external.array(exports_external.unknown()).optional(),
+  instructions: exports_external.string().optional(),
+  max_output_tokens: exports_external.number().int().positive().optional(),
+  temperature: exports_external.number().optional(),
+  stream: exports_external.boolean().optional(),
+  reasoning: reasoning.optional(),
+  tool_choice: exports_external.union([
+    exports_external.enum(["auto", "none", "required"]),
+    exports_external.object({ type: exports_external.enum(["function", "custom"]), name: exports_external.string() })
+  ]).optional(),
+  previous_response_id: exports_external.string().nullish(),
+  store: exports_external.boolean().nullish(),
+  background: exports_external.boolean().nullish(),
+  prompt_cache_key: exports_external.string().nullish()
+});
+var KNOWN3 = [
+  "model",
+  "input",
+  "instructions",
+  "tools",
+  "tool_choice",
+  "stream",
+  "store",
+  "reasoning",
+  "background",
+  "previous_response_id",
+  "max_output_tokens",
+  "temperature",
+  "metadata",
+  "user"
+];
+function refuseStatefulFields(parsed2) {
+  if (typeof parsed2.previous_response_id === "string" && parsed2.previous_response_id.length > 0) {
+    throw new GatewayError("BAD_REQUEST", "previous_response_id: this gateway stores no responses, so prior state cannot be resumed");
+  }
+  if (parsed2.store === true) {
+    throw new GatewayError("BAD_REQUEST", "store: this gateway stores no responses; send store: false or omit it");
+  }
+}
+function readCacheKey(raw) {
+  if (typeof raw !== "string")
+    return;
+  const trimmed = raw.trim();
+  return trimmed.length > 0 && trimmed.length <= 512 ? trimmed : undefined;
+}
+function toIrToolChoice3(c) {
+  if (typeof c === "string")
+    return c === "required" ? { type: "any" } : { type: c };
+  return { type: "tool", name: c.name };
+}
+function toIrReasoning2(r) {
+  return {
+    mode: "adaptive",
+    ...r.effort === undefined ? {} : { effort: r.effort },
+    ...r.summary === "none" ? { display: "omitted" } : {}
+  };
+}
+function clampCallId(raw) {
+  return raw.length <= 64 ? raw : createHash4("sha256").update(raw).digest("hex");
+}
+function roleOf(raw) {
+  if (raw === "assistant")
+    return "assistant";
+  if (raw === "system" || raw === "developer")
+    return "system";
+  return "user";
+}
+function contentPart(part2) {
+  if (!isRecord7(part2))
+    throw new GatewayError("BAD_REQUEST", "input: content part must be an object");
+  const type = part2.type;
+  if (type === "input_text" || type === "output_text") {
+    return { type: "text", text: String(part2.text ?? "") };
+  }
+  if (type === "input_image") {
+    const url2 = typeof part2.image_url === "string" ? part2.image_url : "";
+    if (!url2.startsWith("data:"))
+      return null;
+    const { mediaType, data } = parseDataUrl(url2);
+    return { type: "image", mediaType, data };
+  }
+  throw new GatewayError("BAD_REQUEST", `input: unsupported content part type "${safeToken(type)}"`);
+}
+function messageBlocks(content) {
+  if (typeof content === "string")
+    return [{ type: "text", text: content }];
+  if (!Array.isArray(content))
+    return [];
+  const blocks2 = [];
+  for (const part2 of content) {
+    const block2 = contentPart(part2);
+    if (block2 !== null)
+      blocks2.push(block2);
+  }
+  return blocks2;
+}
+function nativeBlock(item, blockType) {
+  const { type: _type, ...data } = item;
+  return { type: "providerNative", provider: "openai", blockType, data };
+}
+function readInputItems(items) {
+  const dropped = new Set;
+  const messages = [];
+  const push = (role, content) => {
+    if (content.length > 0)
+      messages.push({ role, content });
+  };
+  for (const raw of items) {
+    if (!isRecord7(raw))
+      throw new GatewayError("BAD_REQUEST", "input: item must be an object");
+    const type = raw.type ?? (raw.role === undefined ? undefined : "message");
+    switch (type) {
+      case "message":
+        push(roleOf(raw.role), messageBlocks(raw.content));
+        break;
+      case "function_call":
+      case "custom_tool_call": {
+        const name = typeof raw.name === "string" ? raw.name : "";
+        const callId = typeof raw.call_id === "string" ? raw.call_id : "";
+        if (name === "" || callId === "") {
+          if (callId !== "")
+            dropped.add(callId);
+          else
+            dropped.add("");
+          break;
+        }
+        const input = type === "custom_tool_call" ? { input: typeof raw.input === "string" ? raw.input : "" } : jsonArguments(raw.arguments, clampCallId(callId));
+        push("assistant", [{ type: "toolUse", id: clampCallId(callId), name, input }]);
+        break;
+      }
+      case "function_call_output":
+      case "custom_tool_call_output": {
+        const callId = typeof raw.call_id === "string" ? raw.call_id : "";
+        if (dropped.has(callId))
+          break;
+        push("user", [
+          {
+            type: "toolResult",
+            toolUseId: clampCallId(callId),
+            content: typeof raw.output === "string" ? raw.output : JSON.stringify(raw.output ?? ""),
+            isError: false
+          }
+        ]);
+        break;
+      }
+      case "reasoning":
+      case "local_shell_call":
+        push("assistant", [nativeBlock(raw, String(type))]);
+        break;
+      case "local_shell_call_output":
+        push("user", [nativeBlock(raw, "local_shell_call_output")]);
+        break;
+      case "item_reference":
+        throw new GatewayError("BAD_REQUEST", "input: item_reference names a stored item, and this gateway stores no responses");
+      default:
+        throw new GatewayError("BAD_REQUEST", `input: unsupported item type "${safeToken(type)}"`);
+    }
+  }
+  return messages;
+}
+function jsonArguments(raw, callId) {
+  const text = typeof raw === "string" ? raw : "";
+  try {
+    const parsed2 = text === "" ? {} : JSON.parse(text);
+    return isRecord7(parsed2) ? parsed2 : { value: parsed2 };
+  } catch {
+    throw new GatewayError("BAD_REQUEST", `input: arguments for call ${safeToken(callId)} are not valid JSON`);
+  }
+}
+var TOOL_NAME = /^[A-Za-z0-9_-]{1,128}$/;
+function readTools(raw) {
+  const tools2 = [];
+  for (const entry of raw) {
+    if (!isRecord7(entry))
+      throw new GatewayError("BAD_REQUEST", "tools: each tool must be an object");
+    const type = typeof entry.type === "string" ? entry.type : "";
+    const declared = typeof entry.name === "string" ? entry.name : "";
+    if (type === "function" || type === "custom") {
+      if (!TOOL_NAME.test(declared)) {
+        throw new GatewayError("BAD_REQUEST", `tools: a tool name must match ${TOOL_NAME.source}`);
+      }
+      const description = typeof entry.description === "string" ? entry.description : undefined;
+      tools2.push({
+        kind: "portable",
+        name: declared,
+        ...description === undefined ? {} : { description },
+        inputSchema: type === "custom" ? { type: "object", properties: { input: { type: "string" } }, required: ["input"] } : isRecord7(entry.parameters) ? entry.parameters : { type: "object" }
+      });
+      continue;
+    }
+    const name = declared === "" ? type : declared;
+    if (!TOOL_NAME.test(name)) {
+      throw new GatewayError("BAD_REQUEST", `tools: a tool name must match ${TOOL_NAME.source}`);
+    }
+    const { type: _type, name: _name, ...wire } = entry;
+    tools2.push({ kind: "provider", provider: "openai", type, name, wire });
+  }
+  return tools2;
+}
+function customToolNames(body2) {
+  const names = new Set;
+  if (!isRecord7(body2) || !Array.isArray(body2.tools))
+    return names;
+  for (const entry of body2.tools) {
+    if (isRecord7(entry) && entry.type === "custom" && typeof entry.name === "string") {
+      names.add(entry.name);
+    }
+  }
+  return names;
+}
+function parseResponsesRequest(body2, headers) {
+  if (typeof body2 !== "object" || body2 === null) {
+    throw new GatewayError("BAD_REQUEST", "request body must be a JSON object");
+  }
+  const parsed2 = parseOrThrow2(schema3, body2);
+  refuseStatefulFields(parsed2);
+  const messages = typeof parsed2.input === "string" ? [{ role: "user", content: [{ type: "text", text: parsed2.input }] }] : readInputItems(parsed2.input);
+  if (messages.length === 0) {
+    throw new GatewayError("BAD_REQUEST", "input: at least one input item is required");
+  }
+  const named = normalizeClientModel(parsed2.model);
+  const request2 = {
+    model: named.model,
+    messages,
+    stream: parsed2.stream ?? false
+  };
+  if (parsed2.instructions !== undefined && parsed2.instructions.length > 0) {
+    request2.system = [{ type: "text", text: parsed2.instructions }];
+  }
+  if (parsed2.max_output_tokens !== undefined)
+    request2.maxTokens = parsed2.max_output_tokens;
+  if (parsed2.temperature !== undefined)
+    request2.temperature = parsed2.temperature;
+  if (parsed2.tools !== undefined && parsed2.tools.length > 0)
+    request2.tools = readTools(parsed2.tools);
+  if (parsed2.tool_choice !== undefined)
+    request2.toolChoice = toIrToolChoice3(parsed2.tool_choice);
+  if (parsed2.reasoning !== undefined)
+    request2.reasoning = toIrReasoning2(parsed2.reasoning);
+  if (named.betas.length > 0)
+    request2.betas = named.betas;
+  const conversation = readCacheKey(parsed2.prompt_cache_key) ?? readConversationHeader(headers);
+  if (conversation !== undefined)
+    request2.conversationId = conversation;
+  const extras = extraFields(body2, KNOWN3);
+  if (extras !== undefined)
+    request2.vendor = { openai: extras };
+  return validateRequest(request2);
+}
+
 // apps/gateway/src/routes/models.ts
 var CREATED_AT = new Date(0).toISOString();
 function describeModel(model, credentials) {
@@ -50060,6 +50753,10 @@ function modelListBody(models, credentials) {
 
 // apps/gateway/src/routes/proxy.ts
 var KEEPALIVE_MS = 1e4;
+var RESPONSES_KEEPALIVE_MS = 4000;
+function keepaliveFor(surface, configured2) {
+  return surface === "responses" ? Math.min(configured2, RESPONSES_KEEPALIVE_MS) : configured2;
+}
 var KEEPALIVE = Symbol("keepalive");
 function withKeepalive(pending, ms) {
   let timer;
@@ -50075,10 +50772,18 @@ var SSE_HEADERS = {
   "x-accel-buffering": "no"
 };
 function errorBody(surface, code, message3) {
-  return surface === "anthropic" ? anthropicErrorBody(code, message3) : openaiErrorBody(code, message3);
+  if (surface === "anthropic")
+    return anthropicErrorBody(code, message3);
+  if (surface === "responses")
+    return responsesErrorBody(code, message3);
+  return openaiErrorBody(code, message3);
 }
 function rateLimitHeaders(surface, headroom, now) {
-  return surface === "anthropic" ? anthropicRateLimitHeaders(headroom) : openaiRateLimitHeaders(headroom, now);
+  if (surface === "anthropic")
+    return anthropicRateLimitHeaders(headroom);
+  if (surface === "responses")
+    return responsesRateLimitHeaders(headroom, now);
+  return openaiRateLimitHeaders(headroom, now);
 }
 function afterThisRequest(headroom) {
   const requests = headroom.requests;
@@ -50237,9 +50942,14 @@ async function handle(deps, rateLimiter, surface, request2) {
     const body2 = await request2.json();
     if (captured !== null)
       captured.client.request = body2;
-    const chatRequest = surface === "anthropic" ? parseAnthropicRequest(body2, request2.headers) : parseOpenAIRequest(body2, request2.headers);
+    const chatRequest = surface === "anthropic" ? parseAnthropicRequest(body2, request2.headers) : surface === "responses" ? parseResponsesRequest(body2, request2.headers) : parseOpenAIRequest(body2, request2.headers);
+    const render2 = () => ({
+      requestId,
+      created: Math.floor(deps.now() / 1000),
+      customToolNames: customToolNames(body2)
+    });
     if (key.modelAllowlist !== null && !key.modelAllowlist.includes(chatRequest.model)) {
-      throw new GatewayError("AUTH", `model "${chatRequest.model}" is not allowed for this API key`);
+      throw new GatewayError("AUTH", `model "${safeToken(chatRequest.model)}" is not allowed for this API key`);
     }
     requestedModel = chatRequest.model;
     let began = false;
@@ -50286,7 +50996,7 @@ async function handle(deps, rateLimiter, surface, request2) {
       await finishLog(deps.store, completed, keyId, deps.logger, writeBodies, debit, deps.emit, deps.broadcaster);
     };
     if (chatRequest.stream) {
-      const frames = surface === "anthropic" ? anthropicStream(dispatched.events, requestId) : openaiStream(dispatched.events, requestId, Math.floor(deps.now() / 1000));
+      const frames = surface === "anthropic" ? anthropicStream(dispatched.events, requestId) : surface === "responses" ? responsesStream(dispatched.events, render2()) : openaiStream(dispatched.events, requestId, Math.floor(deps.now() / 1000));
       let onFrame;
       if (captured !== null) {
         const sink = createFrameSink();
@@ -50298,7 +51008,7 @@ async function handle(deps, rateLimiter, surface, request2) {
         release?.();
         await log(cancelled, failure2);
       };
-      const response = sseResponse(frames, finish, deps.keepaliveMs, dispatched.events, limitHeaders(), onFrame);
+      const response = sseResponse(frames, finish, keepaliveFor(surface, deps.keepaliveMs), dispatched.events, limitHeaders(), onFrame);
       streaming = true;
       return response;
     }
@@ -50306,7 +51016,7 @@ async function handle(deps, rateLimiter, surface, request2) {
     for await (const event of dispatched.events)
       events.push(event);
     const failure = events.find((e) => e.type === "error");
-    const responseBody = failure !== undefined ? errorBody(surface, failure.code, failure.message) : surface === "anthropic" ? anthropicResponse(collect(events), requestId) : openaiResponse(collect(events), requestId, Math.floor(deps.now() / 1000));
+    const responseBody = failure !== undefined ? errorBody(surface, failure.code, failure.message) : surface === "anthropic" ? anthropicResponse(collect(events), requestId) : surface === "responses" ? responsesResponse(collect(events), render2()) : openaiResponse(collect(events), requestId, Math.floor(deps.now() / 1000));
     if (captured !== null)
       captured.client.response = responseBody;
     await log();
@@ -50349,6 +51059,9 @@ function proxyRoutes(deps) {
   return new Elysia().post("/v1/messages", ({ request: request2, server }) => {
     server?.timeout(request2, 0);
     return handle(dispatchDeps, rateLimiter, "anthropic", request2);
+  }).post("/v1/responses", ({ request: request2, server }) => {
+    server?.timeout(request2, 0);
+    return handle(dispatchDeps, rateLimiter, "responses", request2);
   }).post("/v1/chat/completions", ({ request: request2, server }) => {
     server?.timeout(request2, 0);
     return handle(dispatchDeps, rateLimiter, "openai", request2);
@@ -50375,7 +51088,7 @@ function proxyRoutes(deps) {
       const body2 = await request2.json();
       const chatRequest = parseAnthropicRequest(body2, request2.headers);
       if (key.modelAllowlist !== null && !key.modelAllowlist.includes(chatRequest.model)) {
-        throw new GatewayError("AUTH", `model "${chatRequest.model}" is not allowed for this API key`);
+        throw new GatewayError("AUTH", `model "${safeToken(chatRequest.model)}" is not allowed for this API key`);
       }
       const { settings } = await dispatchDeps.snapshots.get(deps.now());
       const counted = injectPonytail(chatRequest, { mode: settings.ponytailMode }).request;
@@ -51109,8 +51822,13 @@ function createRing(limits) {
 // apps/gateway/src/app.ts
 var ADMIN_SESSION_TTL_MS = 12 * 60 * 60 * 1000;
 var QUIESCE_MESSAGE = "the gateway is briefly quiesced for database maintenance";
+var QUIESCE_BODY = {
+  "/v1/chat/completions": (m) => openaiErrorBody("OVERLOADED", m),
+  "/v1/responses": (m) => responsesErrorBody("OVERLOADED", m)
+};
 function quiesceResponse(path) {
-  const body2 = path === "/v1/chat/completions" ? openaiErrorBody("OVERLOADED", QUIESCE_MESSAGE) : anthropicErrorBody("OVERLOADED", QUIESCE_MESSAGE);
+  const render2 = QUIESCE_BODY[path];
+  const body2 = render2 === undefined ? anthropicErrorBody("OVERLOADED", QUIESCE_MESSAGE) : render2(QUIESCE_MESSAGE);
   return new Response(JSON.stringify(body2), {
     status: HTTP_STATUS.OVERLOADED,
     headers: { "content-type": "application/json", "retry-after": "5" }