codex-copilot-dx 0.6.12 → 0.6.14

package/src/pm-studio-status.mjs

@@ -40,12 +40,6 @@ const PM_RELAY_ROUTE_NAMES = Object.freeze([
   "pm_chat_completions",
 ]);
 
-function selectRecipe(metadata, recipes) {
-  return recipes.find((recipe) => recipe.version === String(metadata.version)
-    && recipe.build === String(metadata.build)
-    && recipe.bundleIdentifier === String(metadata.bundleIdentifier));
-}
-
 function safeMessage(error) {
   return String(error?.message || "inspection failed").replace(/\s+/g, " ").trim();
 }
@@ -169,21 +163,20 @@ export async function inspectPmStudioStatus({
         build: String(metadata.build),
         bundleIdentifier: String(metadata.bundleIdentifier),
       };
-      let recipe = selectRecipe(normalized, recipes);
+      let recipe = null;
       let compatibilityError = null;
-      if (!recipe) {
-        try {
-          recipe = resolveCompatibleRecipe({
-            appPath,
-            home,
-            backupRoot,
-            metadata: normalized,
-            recipes,
-            operations,
-          });
-        } catch (error) {
-          compatibilityError = error;
-        }
+      try {
+        recipe = resolveCompatibleRecipe({
+          appPath,
+          home,
+          backupRoot,
+          metadata: normalized,
+          recipes,
+          operations,
+          inspectApp,
+        });
+      } catch (error) {
+        compatibilityError = error;
       }
       if (recipe) {
         app = { ...inspectApp({ appPath, recipe, operations }), recipe: recipe.id };
@@ -272,8 +265,8 @@ function appStatusItem(result, commandName) {
   if (app.state === "legacy") {
     return { kind: "err", component: "App patch", detail: `${version}; legacy global-origin patch`, message: `PM Studio ${version} has a legacy global-origin patch; run ${commandName} pms setup to migrate` };
   }
-  if (app.state === "clean") return { kind: "warn", component: "App patch", detail: `${version}; supported, not patched`, message: `PM Studio ${version} is supported but not patched; run ${commandName} pms setup` };
-  if (app.state === "unsupported") return { kind: "err", component: "App patch", detail: `${version}; compatibility unverified`, message: `PM Studio ${version} compatibility cannot be safely verified; no files will be changed` };
+  if (app.state === "clean") return { kind: "warn", component: "App patch", detail: `${version}; compatible structure, not patched`, message: `PM Studio ${version} has a compatible local patch structure but is not patched; run ${commandName} pms setup` };
+  if (app.state === "unsupported") return { kind: "err", component: "App patch", detail: `${version}; structure incompatible`, message: `PM Studio ${version} does not expose one uniquely compatible patch structure; no files will be changed` };
   if (app.state === "drift" && app.patchRecipeMatched) {
     return { kind: "err", component: "App patch", detail: `${version}; patch record drift`, message: `PM Studio ${version} matches the patch recipe, but its installed patch record is not verified: ${app.issues.join("; ")}` };
   }

package/src/responses-bridge.mjs

@@ -38,6 +38,23 @@ export function responsesBodyUsesCustomTools(body) {
     && body.input.some((item) => item?.type === "custom_tool_call" || item?.type === "custom_tool_call_output");
 }
 
+function chatCompatibilityError(kind, itemType) {
+  const type = typeof itemType === "string" && itemType ? itemType : "unknown";
+  const message = `Responses ${kind} type "${type}" cannot be represented by Chat Completions`;
+  const error = new Error(message);
+  error.statusCode = 400;
+  error.code = "ccdx_responses_chat_incompatible";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "invalid_request_error",
+      code: error.code,
+      item_type: type,
+    },
+  };
+  return error;
+}
+
 export function responsesToChat(body) {
   const messages = [];
   if (body.instructions) messages.push({ role: "system", content: body.instructions });
@@ -65,19 +82,36 @@ export function responsesToChat(body) {
   if (typeof body.input === "string") {
     messages.push({ role: "user", content: body.input });
   } else if (Array.isArray(body.input)) {
-    for (const item of body.input) {
-      if (item.type === "message") {
+    for (let index = 0; index < body.input.length; index += 1) {
+      const item = body.input[index];
+      const isEasyMessage = item?.type === undefined
+        && ["user", "assistant", "system", "developer"].includes(item?.role)
+        && Object.prototype.hasOwnProperty.call(item, "content");
+      if (item?.type === "message" || isEasyMessage) {
         messages.push({ role: item.role, content: messageContent(item.content) });
-      } else if (["input_image", "image_url", "image"].includes(item.type)) {
+      } else if (["input_image", "image_url", "image"].includes(item?.type)) {
         messages.push({ role: "user", content: messageContent([item]) });
-      } else if (item.type === "function_call") {
+      } else if (item?.type === "function_call") {
+        const toolCalls = [];
+        while (index < body.input.length && body.input[index]?.type === "function_call") {
+          const call = body.input[index];
+          toolCalls.push({
+            id: call.call_id || randomUUID(),
+            type: "function",
+            function: { name: call.name, arguments: call.arguments },
+          });
+          index += 1;
+        }
+        index -= 1;
         messages.push({
           role: "assistant",
           content: null,
-          tool_calls: [{ id: item.call_id || randomUUID(), type: "function", function: { name: item.name, arguments: item.arguments } }],
+          tool_calls: toolCalls,
         });
-      } else if (item.type === "function_call_output") {
+      } else if (item?.type === "function_call_output") {
         messages.push({ role: "tool", tool_call_id: item.call_id, content: typeof item.output === "string" ? item.output : JSON.stringify(item.output) });
+      } else {
+        throw chatCompatibilityError("input item", item?.type);
       }
     }
   }
@@ -90,9 +124,10 @@ export function responsesToChat(body) {
   if (maxTok !== undefined) chatReq.max_completion_tokens = maxTok;
 
   if (body.tools?.length) {
+    const unsupportedTool = body.tools.find((tool) => tool?.type !== "function");
+    if (unsupportedTool) throw chatCompatibilityError("tool", unsupportedTool?.type);
     chatReq.tools = body.tools
       .map((tool) => {
-        if (tool?.type !== "function") return null;
         if (tool.function?.name) return cloneJson(tool);
         const fn = {
           name: tool.name,
@@ -112,6 +147,8 @@ export function responsesToChat(body) {
       chatReq.tool_choice = body.tool_choice;
     } else if (body.tool_choice?.type === "function" && body.tool_choice.name) {
       chatReq.tool_choice = { type: "function", function: { name: body.tool_choice.name } };
+    } else {
+      throw chatCompatibilityError("tool choice", body.tool_choice?.type);
     }
   }
   if (body.parallel_tool_calls !== undefined) chatReq.parallel_tool_calls = body.parallel_tool_calls;

package/src/responses-compaction.mjs

@@ -1,10 +1,6 @@
-import { randomUUID } from "node:crypto";
 import { httpError } from "./http-transport.mjs";
 
 const COMPACTION_TRIGGER_TYPE = "compaction_trigger";
-const RETAINED_MESSAGE_ROLES = new Set(["user", "assistant", "developer", "system"]);
-const RETAINED_MESSAGE_TOKEN_BUDGET = 64_000;
-const APPROX_BYTES_PER_TOKEN = 4;
 
 function compactionError(message) {
   const error = httpError(message, 502);
@@ -19,47 +15,6 @@ function compactionError(message) {
   return error;
 }
 
-function normalizeMessageContent(content) {
-  if (typeof content === "string") return [{ type: "input_text", text: content }];
-  if (!Array.isArray(content)) return [];
-  return content.map((part) => {
-    if (!part || typeof part !== "object") return part;
-    return part.type === "output_text"
-      ? { ...part, type: "input_text" }
-      : structuredClone(part);
-  });
-}
-
-function approximateTextTokens(content) {
-  return content.reduce((total, part) => {
-    if (part?.type !== "input_text" || typeof part.text !== "string") return total;
-    return total + Math.ceil(Buffer.byteLength(part.text) / APPROX_BYTES_PER_TOKEN);
-  }, 0);
-}
-
-function retainedMessages(inputItems) {
-  const kept = [];
-  let usedTokens = 0;
-  for (let index = inputItems.length - 1; index >= 0; index -= 1) {
-    const item = inputItems[index];
-    if (item?.type !== "message" || !RETAINED_MESSAGE_ROLES.has(item.role)) continue;
-
-    const content = normalizeMessageContent(item.content);
-    usedTokens += Math.max(approximateTextTokens(content), 1);
-    if (usedTokens > RETAINED_MESSAGE_TOKEN_BUDGET && kept.length > 0) break;
-
-    kept.push({
-      type: "message",
-      id: `msg_${randomUUID().replaceAll("-", "")}`,
-      status: item.status ?? "completed",
-      role: item.role,
-      content,
-      ...(item.phase !== undefined ? { phase: structuredClone(item.phase) } : {}),
-    });
-  }
-  return kept.reverse();
-}
-
 export function prepareResponsesCompactionRequest(reqContext) {
   const input = Array.isArray(reqContext?.body?.input) ? reqContext.body.input : [];
   const compactionInputItems = compactionInputWithoutTrigger(input);
@@ -74,7 +29,7 @@ export function compactionInputWithoutTrigger(input) {
     : [];
 }
 
-export function createResponsesCompactionResult(inputItems, generated) {
+export function createResponsesCompactionResult(_inputItems, generated) {
   if (!generated || typeof generated !== "object" || !generated.id || !Array.isArray(generated.output)) {
     throw compactionError("Copilot compaction returned an invalid response envelope");
   }
@@ -95,10 +50,6 @@ export function createResponsesCompactionResult(inputItems, generated) {
   return {
     ...generated,
     object: "response.compaction",
-    output: [
-      ...retainedMessages(Array.isArray(inputItems) ? inputItems : []),
-      ...compactionItems,
-    ],
   };
 }
 

package/src/responses-proxy.mjs

@@ -81,15 +81,38 @@ function inspectResponseSseEvent(state, eventName, data) {
   state.completed = { response, event };
 }
 
-function readSseEvents(buffer, onEvent) {
-  while (true) {
-    const match = buffer.match(/\r?\n\r?\n/);
-    if (!match) return buffer;
-    const chunk = buffer.slice(0, match.index);
-    if (Buffer.byteLength(chunk) > MAX_SSE_BUFFER_BYTES) {
+function createResponseSseInspector(state) {
+  let eventBuffer = Buffer.allocUnsafe(Math.min(4096, MAX_SSE_BUFFER_BYTES + 4));
+  let eventLength = 0;
+  let previous1 = -1;
+  let previous2 = -1;
+  let previous3 = -1;
+
+  const ensureCapacity = (required) => {
+    if (required > MAX_SSE_BUFFER_BYTES + 4) {
+      throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
+    }
+    if (required <= eventBuffer.length) return;
+    let capacity = eventBuffer.length;
+    while (capacity < required) capacity = Math.min(MAX_SSE_BUFFER_BYTES + 4, Math.max(capacity * 2, required));
+    const next = Buffer.allocUnsafe(capacity);
+    eventBuffer.copy(next, 0, 0, eventLength);
+    eventBuffer = next;
+  };
+
+  const append = (bytes) => {
+    if (!bytes.byteLength) return;
+    ensureCapacity(eventLength + bytes.byteLength);
+    eventBuffer.set(bytes, eventLength);
+    eventLength += bytes.byteLength;
+  };
+
+  const inspectEvent = (delimiterLength) => {
+    const contentLength = eventLength - delimiterLength;
+    if (contentLength > MAX_SSE_BUFFER_BYTES) {
       throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
     }
-    buffer = buffer.slice(match.index + match[0].length);
+    const chunk = eventBuffer.subarray(0, contentLength).toString("utf8");
     const lines = chunk.split(/\r?\n/);
     const eventName = lines
       .find((line) => line.startsWith("event:"))
@@ -99,8 +122,73 @@ function readSseEvents(buffer, onEvent) {
       .filter((line) => line.startsWith("data:"))
       .map((line) => line.slice(5).trimStart())
       .join("\n");
-    if (data) onEvent(eventName, data);
+    if (data) inspectResponseSseEvent(state, eventName, data);
+    eventLength = 0;
+    previous1 = -1;
+    previous2 = -1;
+    previous3 = -1;
+  };
+
+  return {
+    push(value) {
+      let segmentStart = 0;
+      for (let index = 0; index < value.byteLength; index += 1) {
+        const byte = value[index];
+        let delimiterLength = 0;
+        if (byte === 0x0a && previous1 === 0x0a) {
+          delimiterLength = previous2 === 0x0d ? 3 : 2;
+        } else if (byte === 0x0a && previous1 === 0x0d && previous2 === 0x0a) {
+          delimiterLength = previous3 === 0x0d ? 4 : 3;
+        }
+        if (delimiterLength) {
+          append(value.subarray(segmentStart, index + 1));
+          inspectEvent(delimiterLength);
+          segmentStart = index + 1;
+          if (state.sawTerminal) return index + 1;
+          continue;
+        }
+        previous3 = previous2;
+        previous2 = previous1;
+        previous1 = byte;
+      }
+      append(value.subarray(segmentStart));
+      if (eventLength > MAX_SSE_BUFFER_BYTES + 3) {
+        throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
+      }
+      return null;
+    },
+  };
+}
+
+function invalidResponsesResponse(message) {
+  const error = httpError(message, 502);
+  error.code = "ccdx_invalid_responses_response";
+  error.jsonBody = {
+    error: {
+      message,
+      type: "upstream_error",
+      code: error.code,
+    },
+  };
+  return error;
+}
+
+function parseSuccessfulResponsesResult(text) {
+  let response;
+  try {
+    response = JSON.parse(text);
+  } catch {
+    throw invalidResponsesResponse("Copilot Responses returned invalid JSON");
+  }
+  if (!response
+    || typeof response !== "object"
+    || Array.isArray(response)
+    || typeof response.id !== "string"
+    || response.id.length === 0
+    || !Array.isArray(response.output)) {
+    throw invalidResponsesResponse("Copilot Responses returned an invalid response envelope");
   }
+  return response;
 }
 
 function storeCompletedResponse(reqContext, completed) {
@@ -138,35 +226,26 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       Connection: "keep-alive",
     });
     const reader = resp.body.getReader();
-    const decoder = new TextDecoder();
-    let buffer = "";
     const streamState = {
       completed: null,
       sawTerminal: false,
       sawOutput: false,
       toolArgumentGuard: new ToolArgumentDeltaGuard(),
     };
+    const inspector = createResponseSseInspector(streamState);
     try {
       while (true) {
         const { done, value } = await reader.read();
         if (done) {
-          buffer += decoder.decode();
-          if (Buffer.byteLength(buffer) > MAX_SSE_BUFFER_BYTES) {
-            throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
-          }
-          readSseEvents(buffer, (eventName, data) => inspectResponseSseEvent(streamState, eventName, data));
           if (!streamState.sawTerminal) throw incompleteUpstreamStream("a terminal Responses event");
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();
           return { successful: Boolean(streamState.completed), compacted: false };
         }
         options.abort?.setTimeout(options.streamIdleTimeoutMs, "stream_idle_timeout");
-        buffer += decoder.decode(value, { stream: true });
-        buffer = readSseEvents(buffer, (eventName, data) => inspectResponseSseEvent(streamState, eventName, data));
-        if (Buffer.byteLength(buffer) > MAX_SSE_BUFFER_BYTES) {
-          throw httpError(`Upstream SSE buffer exceeds ${MAX_SSE_BUFFER_BYTES} bytes`, 502);
-        }
-        if (!await writeOrDrain(res, value)) return;
+        const terminalOffset = inspector.push(value);
+        const forwarded = terminalOffset === null ? value : value.subarray(0, terminalOffset);
+        if (forwarded.byteLength > 0 && !await writeOrDrain(res, forwarded)) return;
         if (streamState.sawTerminal) {
           storeCompletedResponse(reqContext, streamState.completed);
           res.end();
@@ -202,24 +281,26 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       res.end(JSON.stringify(response));
       return { successful: true, compacted: true };
     }
+    if (resp.ok) {
+      const response = parseSuccessfulResponsesResult(data);
+      rememberResponseHistory(reqContext, response);
+      recordResponsesUsage({
+        surface: reqContext.surface,
+        mode: "json",
+        model: reqContext.body?.model,
+        response,
+        event: response,
+      });
+      res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
+        contentType: "application/json",
+      }));
+      res.end(data);
+      return { successful: true, compacted: false };
+    }
     res.writeHead(resp.status, safeUpstreamResponseHeaders(resp.headers, {
       contentType: "application/json",
     }));
     res.end(data);
-    if (resp.ok) {
-      try {
-        const response = JSON.parse(data);
-        rememberResponseHistory(reqContext, response);
-        recordResponsesUsage({
-          surface: reqContext.surface,
-          mode: "json",
-          model: reqContext.body?.model,
-          response,
-          event: response,
-        });
-        return { successful: true, compacted: false };
-      } catch {}
-    }
     return { successful: false, compacted: false };
   }
 }

package/src/responses-request.mjs

@@ -46,7 +46,7 @@ export function stripInternalResponsesInputFields(inputItems, { assertActive } =
 
 function responsesOutputItems(output) {
   if (!Array.isArray(output)) return [];
-  return output.filter((item) => ["message", "function_call", "custom_tool_call"].includes(item?.type));
+  return output.filter((item) => item && typeof item === "object");
 }
 
 function isCompactedResponsesOutput(output) {
@@ -62,8 +62,7 @@ function isSuccessfulCompactionResponse(response) {
 }
 
 function replayableResponsesOutputItems(output) {
-  if (!Array.isArray(output)) return [];
-  return output.filter((item) => item && typeof item === "object");
+  return responsesOutputItems(output);
 }
 
 function isEncryptedContentPart(value) {

package/src/stream.mjs

@@ -4,33 +4,47 @@ import { loadRuntimeConfig } from "./runtime-config.mjs";
 
 const MAX_SSE_BUFFER_BYTES = loadRuntimeConfig().maxSseBufferBytes;
 
-function assertSseBufferLimit(buffer, maxBufferBytes) {
-  if (Buffer.byteLength(buffer) > maxBufferBytes) {
+function appendLineFragment(parts, fragment, currentBytes, maxBufferBytes) {
+  if (!fragment) return currentBytes;
+  const nextBytes = currentBytes + Buffer.byteLength(fragment);
+  if (nextBytes > maxBufferBytes) {
     throw new Error(`Upstream SSE buffer exceeds ${maxBufferBytes} bytes`);
   }
+  parts.push(fragment);
+  return nextBytes;
 }
 
 export async function* webStreamLines(response, { onChunk, maxBufferBytes = MAX_SSE_BUFFER_BYTES } = {}) {
   const reader = response.body.getReader();
   const decoder = new TextDecoder();
-  let buf = "";
+  let lineParts = [];
+  let lineBytes = 0;
   try {
     while (true) {
       const { done, value } = await reader.read();
       if (done) break;
       onChunk?.(value);
-      buf += decoder.decode(value, { stream: true });
-      const lines = buf.split("\n");
-      buf = lines.pop();
-      assertSseBufferLimit(buf, maxBufferBytes);
-      for (const line of lines) {
-        assertSseBufferLimit(line, maxBufferBytes);
-        yield line.replace(/\r$/, "");
+      const decoded = decoder.decode(value, { stream: true });
+      let start = 0;
+      while (start < decoded.length) {
+        const newline = decoded.indexOf("\n", start);
+        if (newline === -1) {
+          lineBytes = appendLineFragment(lineParts, decoded.slice(start), lineBytes, maxBufferBytes);
+          break;
+        }
+        lineBytes = appendLineFragment(lineParts, decoded.slice(start, newline), lineBytes, maxBufferBytes);
+        const line = lineParts.length > 1 ? lineParts.join("") : (lineParts[0] || "");
+        yield line.endsWith("\r") ? line.slice(0, -1) : line;
+        lineParts = [];
+        lineBytes = 0;
+        start = newline + 1;
       }
     }
-    buf += decoder.decode();
-    assertSseBufferLimit(buf, maxBufferBytes);
-    if (buf.length > 0) yield buf.replace(/\r$/, "");
+    lineBytes = appendLineFragment(lineParts, decoder.decode(), lineBytes, maxBufferBytes);
+    if (lineParts.length > 0) {
+      const line = lineParts.length > 1 ? lineParts.join("") : lineParts[0];
+      yield line.endsWith("\r") ? line.slice(0, -1) : line;
+    }
   } finally {
     await reader.cancel().catch(() => {});
     reader.releaseLock();