codex-copilot-dx 0.6.13 → 0.6.15

package/src/route-plan.mjs

@@ -0,0 +1,51 @@
+import { createHash } from "node:crypto";
+
+const DISPOSITIONS = new Set(["native", "relay", "reject"]);
+const MAX_AFFINITY_MODEL_BYTES = 512;
+
+function requiredString(value, name) {
+  const normalized = String(value || "").trim();
+  if (!normalized) throw new Error(`Route plan ${name} is required`);
+  return normalized;
+}
+
+export function createRoutePlan({
+  disposition = "relay",
+  model,
+  origin,
+  profile,
+  protocol,
+  surface,
+} = {}) {
+  if (!DISPOSITIONS.has(disposition)) {
+    throw new Error(`Unsupported route disposition: ${disposition}`);
+  }
+  return Object.freeze({
+    disposition,
+    origin: requiredString(origin, "origin"),
+    profile: requiredString(profile, "profile"),
+    protocol: requiredString(protocol, "protocol"),
+    model: requiredString(model, "model"),
+    surface: requiredString(surface, "surface"),
+  });
+}
+
+export function routePlanAffinity(plan) {
+  if (!plan || typeof plan !== "object") return null;
+  const { origin, profile, protocol, model } = plan;
+  if (![origin, profile, protocol, model].every((value) => typeof value === "string" && value.length > 0)) {
+    return null;
+  }
+  const boundedModel = Buffer.byteLength(model) <= MAX_AFFINITY_MODEL_BYTES
+    ? model
+    : `sha256:${createHash("sha256").update(model).digest("hex")}`;
+  return Object.freeze({ origin, profile, protocol, model: boundedModel });
+}
+
+export function sameRoutePlanAffinity(left, right) {
+  return Boolean(left && right)
+    && left.origin === right.origin
+    && left.profile === right.profile
+    && left.protocol === right.protocol
+    && left.model === right.model;
+}

package/src/startup.mjs

@@ -2,9 +2,15 @@ export async function initializeModelRegistry({
   loadCached,
   currentModelDefs,
   refresh,
+  onBackgroundError = () => {},
 }) {
-  if (loadCached()) {
-    return { modelDefs: currentModelDefs(), source: "cache", backgroundRefresh: null };
+  const cached = loadCached();
+  const loaded = cached === true || cached?.loaded === true;
+  if (loaded) {
+    const backgroundRefresh = cached?.stale === true
+      ? runInBackground(refresh, onBackgroundError)
+      : null;
+    return { modelDefs: currentModelDefs(), source: "cache", backgroundRefresh };
   }
 
   return { modelDefs: await refresh(), source: "live", backgroundRefresh: null };

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();