codex-copilot-dx 0.6.14 → 0.6.18

package/src/profile-routing.mjs

@@ -2,6 +2,7 @@ import {
   isClaudeCopilotCatalogEntry,
   isClaudeCopilotModel,
 } from "./models.mjs";
+import { createRoutePlan } from "./route-plan.mjs";
 
 function catalogData(catalog) {
   if (Array.isArray(catalog)) return catalog;
@@ -47,14 +48,51 @@ export function createPmStudioModelRouter({ getCatalog, isClaudeEnabled } = {})
     return { allowed, known };
   }
 
+  function classify(modelId) {
+    const id = String(modelId || "").trim();
+    const { allowed, known } = availability();
+    if (allowed.has(id)) return "claude";
+    if (known.has(id) || id.toLowerCase().startsWith("claude-")) return "unsupported_claude";
+    return "enterprise";
+  }
+
+  function plan(modelId) {
+    const id = String(modelId || "").trim();
+    const modelType = classify(id);
+    const protocol = "openai-chat-completions";
+    if (modelType === "claude") {
+      return createRoutePlan({
+        disposition: "relay",
+        origin: "ccdx",
+        profile: "claude",
+        protocol,
+        model: id,
+        surface: "pm-studio",
+      });
+    }
+    if (modelType === "unsupported_claude") {
+      return createRoutePlan({
+        disposition: "reject",
+        origin: "ccdx",
+        profile: "claude",
+        protocol,
+        model: id || "unknown",
+        surface: "pm-studio",
+      });
+    }
+    return createRoutePlan({
+      disposition: "native",
+      origin: "pm-studio-native",
+      profile: "enterprise",
+      protocol,
+      model: id || "unknown",
+      surface: "pm-studio",
+    });
+  }
+
   return Object.freeze({
-    classify(modelId) {
-      const id = String(modelId || "").trim();
-      const { allowed, known } = availability();
-      if (allowed.has(id)) return "claude";
-      if (known.has(id) || id.toLowerCase().startsWith("claude-")) return "unsupported_claude";
-      return "enterprise";
-    },
+    plan,
+    classify,
     allowedModels() {
       return [...availability().allowed.values()];
     },

package/src/response-history.mjs

@@ -71,6 +71,7 @@ function jsonByteLength(value, seen = new Set()) {
 const histories = new Map();
 const childrenById = new Map();
 const treeLru = new Map();
+const pinnedTrees = new Map();
 const evictedIds = new Set();
 let totalBytes = 0;
 const HISTORY_RUNTIME_CONFIG = loadRuntimeConfig();
@@ -88,6 +89,21 @@ function touchTree(rootId) {
   treeLru.set(rootId, true);
 }
 
+function pinTree(rootId) {
+  if (!rootId) return;
+  pinnedTrees.set(rootId, (pinnedTrees.get(rootId) || 0) + 1);
+}
+
+function unpinTree(rootId) {
+  const count = pinnedTrees.get(rootId) || 0;
+  if (count <= 1) pinnedTrees.delete(rootId);
+  else pinnedTrees.set(rootId, count - 1);
+}
+
+function treeIsPinned(rootId) {
+  return (pinnedTrees.get(rootId) || 0) > 0;
+}
+
 function linkChild(parentId, id) {
   if (!parentId) return;
   let children = childrenById.get(parentId);
@@ -148,18 +164,50 @@ function assignSubtreeRoot(id, rootId) {
   }
 }
 
-function enforceLimits() {
-  while (histories.size > maxEntries || totalBytes > maxBytes) {
-    const oldestRootId = treeLru.keys().next().value;
-    if (!oldestRootId) break;
-    removeSubtree(oldestRootId);
+function subtreeUsage(rootId) {
+  const pending = [rootId];
+  const seen = new Set();
+  let bytes = 0;
+  let entries = 0;
+  while (pending.length) {
+    const id = pending.pop();
+    if (seen.has(id)) continue;
+    seen.add(id);
+    const entry = histories.get(id);
+    if (entry) {
+      entries += 1;
+      bytes += entry.bytes;
+    }
+    const children = childrenById.get(id);
+    if (children) pending.push(...children);
+  }
+  return { bytes, entries };
+}
+
+function makeRoomFor({ additionalBytes, additionalEntries, protectedRoots }) {
+  let projectedBytes = totalBytes + additionalBytes;
+  let projectedEntries = histories.size + additionalEntries;
+  if (projectedEntries <= maxEntries && projectedBytes <= maxBytes) return true;
+
+  const candidates = [];
+  for (const rootId of treeLru.keys()) {
+    if (protectedRoots.has(rootId) || treeIsPinned(rootId)) continue;
+    const usage = subtreeUsage(rootId);
+    candidates.push(rootId);
+    projectedBytes -= usage.bytes;
+    projectedEntries -= usage.entries;
+    if (projectedEntries <= maxEntries && projectedBytes <= maxBytes) break;
   }
+  if (projectedEntries > maxEntries || projectedBytes > maxBytes) return false;
+  for (const rootId of candidates) removeSubtree(rootId);
+  return true;
 }
 
 export function clearResponseHistoryForTests() {
   histories.clear();
   childrenById.clear();
   treeLru.clear();
+  pinnedTrees.clear();
   evictedIds.clear();
   totalBytes = 0;
   maxBytes = DEFAULT_MAX_BYTES;
@@ -202,13 +250,61 @@ export function responseHistoryMaterializedBytes(responseId) {
   return chain.reduce((bytes, entry) => bytes + entry.bytes, 0);
 }
 
-export function materializeResponseHistory(responseId, { assertActive } = {}) {
+export function acquireResponseHistorySnapshot(responseId, { assertActive, signal } = {}) {
+  assertActive?.();
+  if (signal?.aborted) throw signal.reason || new DOMException("The operation was aborted", "AbortError");
+  const { chain, rootId } = responseHistoryChain(responseId);
+  const entries = chain.slice().reverse();
+  const bytes = chain.reduce((total, entry) => total + entry.bytes, 0);
+  pinTree(rootId);
+
+  let released = false;
+  const release = () => {
+    if (released) return;
+    released = true;
+    signal?.removeEventListener("abort", release);
+    unpinTree(rootId);
+  };
+  signal?.addEventListener("abort", release, { once: true });
+
+  return Object.freeze({
+    responseId,
+    rootId,
+    bytes,
+    materialize({ assertActive: assertSnapshotActive, routeMetadata } = {}) {
+      assertSnapshotActive?.();
+      if (released) throw new Error("Response history snapshot has been released");
+      const items = [];
+      for (let index = 0; index < entries.length; index += 1) {
+        if ((index & 63) === 0) assertSnapshotActive?.();
+        const entry = entries[index];
+        routeMetadata?.push({
+          affinity: entry.routeAffinity || null,
+          hasOpaque: entry.hasOpaque === true,
+        });
+        items.push(...entry.inputItems, ...entry.outputItems);
+      }
+      assertSnapshotActive?.();
+      const materialized = cloneJson(items);
+      assertSnapshotActive?.();
+      touchTree(rootId);
+      return materialized;
+    },
+    release,
+  });
+}
+
+export function materializeResponseHistory(responseId, { assertActive, routeMetadata } = {}) {
   assertActive?.();
   const { chain, rootId } = responseHistoryChain(responseId);
   const items = [];
   for (let index = 0; index < chain.length; index += 1) {
     if ((index & 63) === 0) assertActive?.();
     const entry = chain[chain.length - index - 1];
+    routeMetadata?.push({
+      affinity: entry.routeAffinity || null,
+      hasOpaque: entry.hasOpaque === true,
+    });
     items.push(...entry.inputItems, ...entry.outputItems);
   }
   assertActive?.();
@@ -218,27 +314,57 @@ export function materializeResponseHistory(responseId, { assertActive } = {}) {
   return materialized;
 }
 
-export function rememberResponseHistoryNode({ id, parentId, inputItems, outputItems, takeOwnership = false }) {
-  if (!id || !Array.isArray(inputItems)) return;
+export function rememberResponseHistoryNode({
+  id,
+  parentId,
+  inputItems,
+  outputItems,
+  hasOpaque = false,
+  routeAffinity = null,
+  takeOwnership = false,
+}) {
+  if (!id || !Array.isArray(inputItems)) return false;
+  const existing = histories.get(id);
+  const parentEntry = parentId ? histories.get(parentId) : null;
+  if (parentId && !parentEntry) {
+    if (!existing) rememberEvictedId(id);
+    return false;
+  }
   clearResponsesToolOutputPartsCache(inputItems);
   clearResponsesToolOutputPartsCache(outputItems);
-  const bytes = jsonByteLength([inputItems, outputItems]);
+  const historyValue = routeAffinity
+    ? [inputItems, outputItems, { routeAffinity, hasOpaque: hasOpaque === true }]
+    : [inputItems, outputItems];
+  const bytes = jsonByteLength(historyValue);
   if (bytes > maxBytes) {
-    if (histories.has(id)) removeSubtree(id);
-    rememberEvictedId(id);
-    return;
+    if (!existing) rememberEvictedId(id);
+    else if (!treeIsPinned(existing.rootId)) removeSubtree(id);
+    return false;
   }
-  const existing = histories.get(id);
-  const parentEntry = parentId ? histories.get(parentId) : null;
-  const rootId = parentEntry?.rootId || (parentId ? existing?.rootId : id) || id;
+  const rootId = parentEntry?.rootId || id;
   const entry = {
     parentId: parentId || null,
     rootId,
     inputItems: takeOwnership ? inputItems : cloneJson(inputItems),
     outputItems: takeOwnership ? outputItems : cloneJson(outputItems),
+    hasOpaque: hasOpaque === true,
+    routeAffinity: routeAffinity ? cloneJson(routeAffinity) : null,
     bytes,
   };
   const oldRootId = existing?.rootId;
+  const protectedRoots = new Set([rootId]);
+  if (oldRootId) protectedRoots.add(oldRootId);
+  if (!makeRoomFor({
+    additionalBytes: bytes - (existing?.bytes || 0),
+    additionalEntries: existing ? 0 : 1,
+    protectedRoots,
+  })) {
+    if (!existing) {
+      if (parentEntry && !treeIsPinned(rootId)) removeSubtree(rootId);
+      rememberEvictedId(id);
+    }
+    return false;
+  }
   if (existing) {
     totalBytes -= existing.bytes;
     unlinkChild(existing.parentId, id);
@@ -253,5 +379,5 @@ export function rememberResponseHistoryNode({ id, parentId, inputItems, outputIt
   totalBytes += entry.bytes;
   evictedIds.delete(id);
   touchTree(rootId);
-  enforceLimits();
+  return true;
 }

package/src/responses-bridge.mjs

@@ -1,7 +1,12 @@
 import { randomUUID } from "node:crypto";
 import { chatCompletions } from "./copilot.mjs";
 import { webStreamLines } from "./stream.mjs";
-import { abortErrorStatusCode, isAbortLikeError } from "./http-transport.mjs";
+import {
+  abortErrorStatusCode,
+  isAbortLikeError,
+  MAX_UPSTREAM_ERROR_BODY_BYTES,
+  readBoundedResponseText,
+} from "./http-transport.mjs";
 import {
   incompleteUpstreamStream,
   invalidUpstreamStream,
@@ -216,7 +221,10 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     return false;
   }
   if (!resp.ok) {
-    await onError(resp.status, await resp.text(), undefined, resp);
+    await onError(resp.status, await readBoundedResponseText(resp, {
+      maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
+      label: "Copilot Chat error body",
+    }), undefined, resp);
     return false;
   }
   try {
@@ -235,6 +243,13 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   let usage = { input_tokens: 0, output_tokens: 0, total_tokens: 0 };
   const toolCalls = new Map();
   const toolArgumentGuard = new ToolArgumentDeltaGuard();
+  const downstreamClosed = Symbol("downstream-closed");
+  const configuredEmitEvent = emitEvent;
+  emitEvent = async (...args) => {
+    const written = await configuredEmitEvent(...args);
+    if (written === false) throw downstreamClosed;
+    return written;
+  };
   let performanceOutputSeen = false;
   const markPerformanceOutput = () => {
     if (performanceOutputSeen) return;
@@ -242,8 +257,6 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
     markFirstOutput();
   };
 
-  await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
-
   const ensureMessageItem = async () => {
     if (messageItem) return messageItem;
     messageItem = { id: `msg_${uid()}`, outputIndex: nextOutputIndex++ };
@@ -331,6 +344,7 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
   };
 
   try {
+    await emitEvent("response.created", { response: { id: respId, object: "response", status: "in_progress", model: actualModel, output: [] } });
     for await (const line of webStreamLines(resp, {
       onChunk: () => abort?.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout"),
     })) {
@@ -386,6 +400,10 @@ export async function forwardToChat(chatReq, emitEvent, onDone, onError, options
       }
     }
   } catch (e) {
+    if (e === downstreamClosed) {
+      await resp.body?.cancel?.().catch?.(() => {});
+      return false;
+    }
     const statusCode = isAbortLikeError(e) ? abortErrorStatusCode(abort?.reason) : (e?.statusCode || 502);
     await onError(statusCode, e?.message || "upstream stream error", e);
     return false;