codex-copilot-dx 0.4.42 → 0.4.44

package/src/responses-request.mjs

@@ -31,7 +31,24 @@ export function stripInternalResponsesInputFields(inputItems) {
 
 function responsesOutputItems(output) {
   if (!Array.isArray(output)) return [];
-  return output.filter((item) => item?.type === "message" || item?.type === "function_call");
+  return output.filter((item) => ["message", "function_call", "custom_tool_call"].includes(item?.type));
+}
+
+function isCompactedResponsesOutput(output) {
+  return Array.isArray(output) && output.some((item) => item?.type === "compaction");
+}
+
+function isSuccessfulCompactionResponse(response) {
+  if (!isCompactedResponsesOutput(response?.output)) return false;
+  if (Object.prototype.hasOwnProperty.call(response, "status") && response.status !== "completed") {
+    return false;
+  }
+  return response.object === "response.compaction" || response.status === "completed";
+}
+
+function replayableResponsesOutputItems(output) {
+  if (!Array.isArray(output)) return [];
+  return output.filter((item) => item && typeof item === "object");
 }
 
 function stripEncryptedReasoningValue(value, state) {
@@ -62,16 +79,21 @@ function isEncryptedReasoningInputItem(item) {
 export function sanitizeEncryptedReasoningRequest(reqContext) {
   const state = { changed: false };
   let body = cloneJson(reqContext.body);
+  let currentInputStart = reqContext.currentInputStart;
   if (Array.isArray(body.input)) {
     const input = [];
-    for (const item of body.input) {
+    let retainedBeforeCurrent = 0;
+    for (let index = 0; index < body.input.length; index += 1) {
+      const item = body.input[index];
       if (isEncryptedReasoningInputItem(item)) {
         state.changed = true;
         continue;
       }
       input.push(stripEncryptedReasoningValue(item, state));
+      if (Number.isFinite(currentInputStart) && index < currentInputStart) retainedBeforeCurrent += 1;
     }
     body.input = input;
+    if (Number.isFinite(currentInputStart)) currentInputStart = retainedBeforeCurrent;
   } else {
     body = stripEncryptedReasoningValue(body, state);
   }
@@ -84,6 +106,7 @@ export function sanitizeEncryptedReasoningRequest(reqContext) {
   return {
     ...reqContext,
     body,
+    currentInputStart,
     inputItems: Array.isArray(body.input) ? body.input : reqContext.inputItems,
     historyInputItems,
   };
@@ -129,8 +152,14 @@ export function sanitizeImageNamespaceCollisionRequest(reqContext) {
 export async function openCopilotResponse(reqContext, upstream = copilotResponses, options = {}) {
   let encryptedRetried = false;
   let imageNamespaceRetried = false;
+  let payloadPrepared = false;
   for (let attempt = 0; attempt < 3; attempt += 1) {
-    const resp = await upstream(reqContext.body, { signal: options.signal });
+    const resp = await upstream(reqContext.body, {
+      signal: options.signal,
+      currentInputStart: reqContext.currentInputStart,
+      payloadPrepared,
+    });
+    payloadPrepared = true;
     if (resp.ok) return { resp, reqContext };
 
     const errorText = await resp.text();
@@ -164,6 +193,9 @@ function isBuiltinImageTool(tool) {
 export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
   const body = mutate ? reqBody : cloneJson(reqBody);
   const currentInputItems = responsesInputItems(body.input, { clone: !mutate });
+  const currentInputRefs = new Set(
+    currentInputItems.filter((item) => item && typeof item === "object"),
+  );
   const previousId = body.previous_response_id;
   let historyItems = [];
 
@@ -193,10 +225,12 @@ export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
   }
   stripInternalResponsesInputFields(body.input);
   stripInternalResponsesInputFields(historyInputItems);
+  const retainedCurrentInputStart = body.input.findIndex((item) => currentInputRefs.has(item));
 
   return {
     body,
     inputItems: body.input,
+    currentInputStart: retainedCurrentInputStart < 0 ? body.input.length : retainedCurrentInputStart,
     historyParentId: previousId ?? null,
     historyInputItems,
     takeHistoryOwnership: mutate,
@@ -205,11 +239,14 @@ export function prepareResponsesRequest(reqBody, { mutate = false } = {}) {
 
 export function rememberResponseHistory(reqContext, responseJson) {
   if (!responseJson?.id || !Array.isArray(reqContext?.historyInputItems || reqContext?.inputItems)) return;
-  const sourceInputItems = reqContext.historyInputItems || reqContext.inputItems;
-  const sourceOutputItems = responsesOutputItems(responseJson.output);
+  const compacted = isSuccessfulCompactionResponse(responseJson);
+  const sourceInputItems = compacted ? [] : reqContext.historyInputItems || reqContext.inputItems;
+  const sourceOutputItems = compacted
+    ? replayableResponsesOutputItems(responseJson.output)
+    : responsesOutputItems(responseJson.output);
   rememberResponseHistoryNode({
     id: responseJson.id,
-    parentId: reqContext.historyParentId,
+    parentId: compacted ? null : reqContext.historyParentId,
     inputItems: sourceInputItems,
     outputItems: sourceOutputItems,
     takeOwnership: reqContext.takeHistoryOwnership,

package/src/stream-contract.mjs

@@ -0,0 +1,102 @@
+const DEFAULT_BLANK_TOOL_ARGUMENT_LIMIT = 20;
+
+function streamProtocolError(message, code) {
+  const error = new Error(message);
+  error.statusCode = 502;
+  error.code = code;
+  error.jsonBody = {
+    error: {
+      message,
+      type: "upstream_protocol_error",
+      code,
+    },
+  };
+  return error;
+}
+
+export function invalidUpstreamStream(message, code = "upstream_stream_invalid") {
+  return streamProtocolError(message, code);
+}
+
+export function withChatStreamUsage(request) {
+  const streamOptions = request?.stream_options && typeof request.stream_options === "object"
+    ? request.stream_options
+    : {};
+  if (request?.stream === true && streamOptions.include_usage === true) return request;
+  return {
+    ...request,
+    stream: true,
+    stream_options: { ...streamOptions, include_usage: true },
+  };
+}
+
+export async function requireUpstreamEventStream(response) {
+  let error = null;
+  if (!response?.body) {
+    error = streamProtocolError(
+      "Upstream returned a successful streaming response without a body",
+      "upstream_stream_body_missing",
+    );
+  } else {
+    const contentType = response.headers?.get?.("content-type") || "";
+    const mediaType = contentType.split(";", 1)[0].trim().toLowerCase();
+    if (mediaType !== "text/event-stream") {
+      error = streamProtocolError(
+        "Upstream returned a successful streaming response with a non-SSE Content-Type",
+        "upstream_stream_content_type_invalid",
+      );
+    }
+  }
+
+  if (!error) return;
+  await response?.body?.cancel?.().catch(() => {});
+  throw error;
+}
+
+export function incompleteUpstreamStream(expectedTerminator) {
+  return streamProtocolError(
+    `Upstream stream ended before ${expectedTerminator}`,
+    "upstream_stream_incomplete",
+  );
+}
+
+export function upstreamChatStreamError(event) {
+  const payload = event?.error;
+  if (!payload || typeof payload !== "object") return null;
+  const type = typeof payload.type === "string" && payload.type ? `${payload.type}: ` : "";
+  const message = typeof payload.message === "string" && payload.message
+    ? payload.message.slice(0, 500)
+    : "Upstream stream error";
+  return streamProtocolError(
+    `Upstream Chat Completions SSE error: ${type}${message}`,
+    "upstream_chat_stream_error",
+  );
+}
+
+export class ToolArgumentDeltaGuard {
+  constructor(limit = DEFAULT_BLANK_TOOL_ARGUMENT_LIMIT) {
+    this.limit = limit;
+    this.whitespaceRuns = new Map();
+  }
+
+  observe(callIndex, delta) {
+    if (typeof delta !== "string") return;
+    const key = callIndex ?? "unknown";
+    let count = this.whitespaceRuns.get(key) || 0;
+    for (const character of delta) {
+      if (character === "\r" || character === "\n" || character === "\t") {
+        count += 1;
+        if (count > this.limit) {
+          this.whitespaceRuns.set(key, count);
+          throw streamProtocolError(
+            `Upstream sent more than ${this.limit} consecutive line-break or tab characters in tool arguments`,
+            "upstream_tool_arguments_stalled",
+          );
+        }
+      } else if (character !== " ") {
+        count = 0;
+      }
+    }
+    this.whitespaceRuns.set(key, count);
+  }
+}

package/src/stream-errors.mjs

@@ -1,7 +1,8 @@
 import { writeOrDrain } from "./http-transport.mjs";
+import { markStreamFailure } from "./stream-performance.mjs";
 
 function streamErrorData(protocol, error, abort) {
-  const code = abort?.reason || "upstream_stream_error";
+  const code = abort?.reason || error?.code || "upstream_stream_error";
   const message = `${code}: ${error?.message || "Upstream stream failed"}`;
   if (protocol === "anthropic") {
     return { type: "error", error: { type: "api_error", message } };
@@ -10,6 +11,7 @@ function streamErrorData(protocol, error, abort) {
 }
 
 export async function endStreamWithError(res, protocol, error, abort) {
+  markStreamFailure();
   if (res.destroyed || res.writableEnded) return;
   const data = streamErrorData(protocol, error, abort);
   await writeOrDrain(res, `event: error\ndata: ${JSON.stringify(data)}\n\n`).catch(() => false);

package/src/stream-performance.mjs

@@ -0,0 +1,177 @@
+import { performance } from "node:perf_hooks";
+import { currentRequestContext } from "./request-context.mjs";
+
+const PERFORMANCE_ROUTES = Object.freeze(["responses", "responses_compact", "messages"]);
+const TTFT_EDGES_MS = Object.freeze([
+  100, 200, 300, 500, 700, 1_000, 1_400, 2_000, 2_800, 4_000,
+  5_500, 8_000, 12_000, 16_000, 24_000, 36_000, 60_000, 120_000, 300_000,
+]);
+const TPOT_EDGES_US = Object.freeze([
+  500, 1_000, 2_000, 3_333, 5_000, 6_667, 8_333, 10_000, 12_500, 14_286,
+  16_667, 20_000, 25_000, 33_333, 40_000, 50_000, 66_667, 100_000,
+  150_000, 250_000, 500_000, 1_000_000, 2_500_000, 10_000_000,
+]);
+
+const RESPONSES_OUTPUT_EVENT_TYPES = new Set([
+  "response.output_text.delta",
+  "response.function_call_arguments.delta",
+  "response.custom_tool_call_input.delta",
+  "response.refusal.delta",
+  "response.reasoning_text.delta",
+  "response.reasoning_summary_text.delta",
+]);
+
+function nonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+
+export function isResponsesOutputEvent(event, eventType = event?.type) {
+  return RESPONSES_OUTPUT_EVENT_TYPES.has(eventType) && nonEmptyString(event?.delta);
+}
+
+export function isChatOutputDelta(delta) {
+  if (!delta || typeof delta !== "object") return false;
+  return nonEmptyString(delta.content)
+    || (Array.isArray(delta.tool_calls) && delta.tool_calls.length > 0)
+    || nonEmptyString(delta.refusal)
+    || nonEmptyString(delta.reasoning)
+    || nonEmptyString(delta.reasoning_content)
+    || nonEmptyString(delta.reasoning_text);
+}
+
+function createHistogram(edges) {
+  return {
+    edges,
+    counts: new Uint32Array(edges.length + 1),
+    samples: 0,
+    total: 0,
+    max: 0,
+  };
+}
+
+function observe(histogram, value) {
+  if (!Number.isFinite(value) || value < 0) return;
+  let index = 0;
+  while (index < histogram.edges.length && value > histogram.edges[index]) index += 1;
+  histogram.counts[index] += 1;
+  histogram.samples += 1;
+  histogram.total += value;
+  histogram.max = Math.max(histogram.max, value);
+}
+
+function histogramSnapshot(histogram, unit) {
+  let lower = 0;
+  const buckets = histogram.edges.map((upper, index) => {
+    const bucket = { lower, upper, count: histogram.counts[index] };
+    lower = upper;
+    return bucket;
+  });
+  buckets.push({ lower, upper: null, count: histogram.counts.at(-1) });
+  return {
+    unit,
+    samples: histogram.samples,
+    avg: histogram.samples > 0 ? Number((histogram.total / histogram.samples).toFixed(1)) : 0,
+    max: histogram.max,
+    buckets,
+  };
+}
+
+function createRoutePerformance() {
+  return {
+    ttft: createHistogram(TTFT_EDGES_MS),
+    tpot: createHistogram(TPOT_EDGES_US),
+    success_with_output: 0,
+    errors_with_output: 0,
+    zero_output_errors: 0,
+    neutral: 0,
+  };
+}
+
+function routeSnapshot(route) {
+  return {
+    success_with_output: route.success_with_output,
+    errors_with_output: route.errors_with_output,
+    zero_output_errors: route.zero_output_errors,
+    neutral: route.neutral,
+    ttft_ms: histogramSnapshot(route.ttft, "ms"),
+    tpot_us: histogramSnapshot(route.tpot, "us"),
+  };
+}
+
+export function createStreamPerformanceMetrics({ now = () => performance.now() } = {}) {
+  const routes = Object.fromEntries(PERFORMANCE_ROUTES.map((name) => [name, createRoutePerformance()]));
+
+  return {
+    begin(routeName) {
+      const route = routes[routeName];
+      if (!route) return null;
+      let upstreamStartedAt = null;
+      let firstOutputAt = null;
+      let outputTokens = null;
+      let failed = false;
+      let finished = false;
+
+      return {
+        upstreamStarted() {
+          if (upstreamStartedAt === null) upstreamStartedAt = now();
+        },
+        firstOutput() {
+          if (firstOutputAt === null) firstOutputAt = now();
+        },
+        setOutputTokens(value) {
+          const tokens = Number(value);
+          if (Number.isFinite(tokens) && tokens >= 0) outputTokens = tokens;
+        },
+        fail() {
+          failed = true;
+        },
+        finish({ failed: finishFailed = false } = {}) {
+          if (finished) return;
+          finished = true;
+          failed ||= finishFailed;
+          const finishedAt = now();
+          if (upstreamStartedAt === null) {
+            route.neutral += 1;
+            return;
+          }
+          if (firstOutputAt === null) {
+            if (failed) route.zero_output_errors += 1;
+            else route.neutral += 1;
+            return;
+          }
+          observe(route.ttft, Math.max(0, firstOutputAt - upstreamStartedAt));
+          if (outputTokens !== null && outputTokens >= 2) {
+            observe(route.tpot, Math.max(0, ((finishedAt - firstOutputAt) * 1_000) / (outputTokens - 1)));
+          }
+          if (failed) route.errors_with_output += 1;
+          else route.success_with_output += 1;
+        },
+      };
+    },
+    snapshot() {
+      return {
+        by_route: Object.fromEntries(PERFORMANCE_ROUTES.map((name) => [name, routeSnapshot(routes[name])])),
+      };
+    },
+  };
+}
+
+function tracker() {
+  return currentRequestContext()?.streamPerformance || null;
+}
+
+export function markUpstreamStarted() {
+  tracker()?.upstreamStarted();
+}
+
+export function markFirstOutput() {
+  tracker()?.firstOutput();
+}
+
+export function markOutputTokens(value) {
+  tracker()?.setOutputTokens(value);
+}
+
+export function markStreamFailure() {
+  tracker()?.fail();
+}

package/src/upstream-headers.mjs

@@ -0,0 +1,67 @@
+const REQUEST_ID_HEADERS = [
+  "x-request-id",
+  "x-github-request-id",
+  "x-ms-request-id",
+  "request-id",
+  "x-correlation-id",
+];
+
+const SAFE_EXACT_HEADERS = new Set([
+  "retry-after",
+  "ratelimit-limit",
+  "ratelimit-remaining",
+  "ratelimit-reset",
+  "ratelimit-policy",
+  "openai-model",
+  "openai-processing-ms",
+  "traceparent",
+]);
+
+const SAFE_HEADER_PREFIXES = [
+  "x-ratelimit-",
+  "x-ms-ratelimit-",
+];
+
+function headerValue(headers, name) {
+  const value = headers?.get?.(name);
+  return typeof value === "string" && value.trim() ? value : null;
+}
+
+function canonicalHeaderName(name) {
+  return String(name).split("-").map((part) => (
+    part ? `${part[0].toUpperCase()}${part.slice(1).toLowerCase()}` : part
+  )).join("-");
+}
+
+function isSafeMetadataHeader(name) {
+  return SAFE_EXACT_HEADERS.has(name)
+    || SAFE_HEADER_PREFIXES.some((prefix) => name.startsWith(prefix));
+}
+
+export function safeUpstreamResponseHeaders(headers, {
+  contentType,
+  defaultContentType,
+} = {}) {
+  const out = {};
+  const resolvedContentType = contentType
+    ?? headerValue(headers, "content-type")
+    ?? defaultContentType;
+  if (resolvedContentType) out["Content-Type"] = resolvedContentType;
+
+  if (headers && typeof headers[Symbol.iterator] === "function") {
+    for (const [rawName, value] of headers) {
+      const name = String(rawName).toLowerCase();
+      if (!isSafeMetadataHeader(name)) continue;
+      out[canonicalHeaderName(name)] = value;
+    }
+  }
+
+  for (const name of REQUEST_ID_HEADERS) {
+    const value = headerValue(headers, name);
+    if (value) {
+      out["X-Upstream-Request-Id"] = value;
+      break;
+    }
+  }
+  return out;
+}