codex-copilot-dx 0.6.21 → 0.7.0

package/src/profile-routing.mjs

@@ -1,103 +1,3 @@
-import {
-  isClaudeCopilotCatalogEntry,
-  isClaudeCopilotModel,
-} from "./models.mjs";
-import { createRoutePlan } from "./route-plan.mjs";
-
-function catalogData(catalog) {
-  if (Array.isArray(catalog)) return catalog;
-  return Array.isArray(catalog?.data) ? catalog.data : [];
-}
-
-export function profileRouting({ claudeMode = "inherited", claudeConfigured = false } = {}) {
-  const isolated = claudeMode === "isolated" || claudeConfigured === true;
-  return Object.freeze({ responses: "codex", messages: isolated ? "claude" : "codex" });
-}
-
-export function createPmStudioModelRouter({ getCatalog, isClaudeEnabled } = {}) {
-  if (typeof getCatalog !== "function") throw new Error("getCatalog is required");
-  if (typeof isClaudeEnabled !== "function") throw new Error("isClaudeEnabled is required");
-
-  const unset = Symbol("unset");
-  let cachedCatalog = unset;
-  let cachedEnabled = false;
-  let cachedAllowed = new Map();
-  let cachedKnown = new Set();
-  let rebuilds = 0;
-
-  function availability() {
-    const catalog = getCatalog();
-    const enabled = isClaudeEnabled() === true;
-    if (catalog === cachedCatalog && enabled === cachedEnabled) {
-      return { allowed: cachedAllowed, known: cachedKnown };
-    }
-
-    const allowed = new Map();
-    const known = new Set();
-    for (const model of catalogData(catalog)) {
-      const id = String(model?.id || "").trim();
-      if (!id || !isClaudeCopilotCatalogEntry(model)) continue;
-      known.add(id);
-      if (enabled && isClaudeCopilotModel(model) && !allowed.has(id)) allowed.set(id, model);
-    }
-    cachedCatalog = catalog;
-    cachedEnabled = enabled;
-    cachedAllowed = allowed;
-    cachedKnown = known;
-    rebuilds += 1;
-    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({
-    plan,
-    classify,
-    allowedModels() {
-      return [...availability().allowed.values()];
-    },
-    diagnostics() {
-      return { rebuilds, allowed: cachedAllowed.size, known: cachedKnown.size };
-    },
-  });
+export function profileRouting() {
+  return Object.freeze({ responses: "codex" });
 }

package/src/profile-runtime.mjs

@@ -1,11 +1,8 @@
 import {
-  AUTH_PROFILE_CLAUDE,
   AUTH_PROFILE_CODEX,
-  authProfilePaths,
-  profileReauthMessage,
   readAuthProfileCredentials,
 } from "./auth-profile.mjs";
-import { createCopilotClient, defaultCopilotClient } from "./copilot.mjs";
+import { defaultCopilotClient } from "./copilot.mjs";
 import { githubTokenFingerprint } from "./github-identity.mjs";
 
 function safeProfileStatus(credentials) {
@@ -28,75 +25,25 @@ export function createProfileRuntime({
   home,
   codexClient = defaultCopilotClient,
 } = {}) {
-  const unreadableCredentials = () => ({
-    profile: AUTH_PROFILE_CLAUDE,
-    configured: true,
-    valid: false,
-    reason: "credential_read_failed",
-    token: "",
-    identity: null,
-    paths: authProfilePaths(AUTH_PROFILE_CLAUDE, { home }),
-  });
-  const readCredentials = () => {
-    try {
-      return readAuthProfileCredentials(AUTH_PROFILE_CLAUDE, { home });
-    } catch {
-      return unreadableCredentials();
-    }
-  };
-  const credentials = readCredentials();
-  const claudeProfile = safeProfileStatus(credentials);
-  const claudeCredentialFingerprint = credentials.valid
-    ? githubTokenFingerprint(credentials.token)
-    : "";
-  const isClaudeProfileCurrent = () => {
-    if (!claudeCredentialFingerprint) return false;
-    const current = readCredentials();
-    return current.valid === true
-      && githubTokenFingerprint(current.token) === claudeCredentialFingerprint;
-  };
-  let codexCredentialFingerprint = "";
+  let credentials;
   try {
-    const codexCredentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
-    if (codexCredentials.valid) {
-      codexCredentialFingerprint = githubTokenFingerprint(codexCredentials.token);
-    }
+    credentials = readAuthProfileCredentials(AUTH_PROFILE_CODEX, { home });
   } catch {
-    // The Codex client remains authoritative if its optional metadata cannot
-    // be inspected; only credential-bound cache reuse is disabled.
-  }
-
-  if (!credentials.configured) {
-    return Object.freeze({
-      codexClient,
-      claudeClient: codexClient,
-      claudeMode: "inherited",
-      claudeProfile,
-      codexCredentialFingerprint,
-      claudeCredentialFingerprint: "",
-      isClaudeProfileCurrent,
-    });
+    credentials = {
+      profile: AUTH_PROFILE_CODEX,
+      configured: true,
+      valid: false,
+      reason: "credential_read_failed",
+      token: "",
+      identity: null,
+    };
   }
 
-  const readRuntimeCredentials = credentials.reason === "credential_read_failed"
-    ? () => credentials
-    : readCredentials;
-  const claudeClient = createCopilotClient({
-    profile: AUTH_PROFILE_CLAUDE,
-    home,
-    tokenPath: credentials.paths.tokenPath,
-    allowTokenDiscovery: false,
-    readGithubCredentials: readRuntimeCredentials,
-    reauthMessage: (reason) => `${reason}\n${profileReauthMessage(AUTH_PROFILE_CLAUDE, { home })}`,
-  });
-
   return Object.freeze({
     codexClient,
-    claudeClient,
-    claudeMode: "isolated",
-    claudeProfile,
-    codexCredentialFingerprint,
-    claudeCredentialFingerprint,
-    isClaudeProfileCurrent,
+    codexProfile: safeProfileStatus(credentials),
+    codexCredentialFingerprint: credentials.valid
+      ? githubTokenFingerprint(credentials.token)
+      : "",
   });
 }

package/src/responses-handler.mjs

@@ -286,7 +286,7 @@ export function createResponsesHandler(options) {
               sendJsonError(res, responseError, statusCode || 500);
               return;
             }
-            await endStreamWithError(res, "responses", error || new Error(errMsg), abort);
+            await endStreamWithError(res, error || new Error(errMsg), abort);
           }, {
             signal: abort.signal,
             abort,

package/src/responses-proxy.mjs

@@ -258,7 +258,7 @@ export async function proxyCopilotResponses(reqContext, req, res, upstream = cop
       }
     } catch (e) {
       logRequestFailure("Responses", e, options.abort);
-      await endStreamWithError(res, "responses", e, options.abort);
+      await endStreamWithError(res, e, options.abort);
       return { successful: false, compacted: false };
     } finally {
       await reader.cancel().catch(() => {});

package/src/running-adapter.mjs

@@ -3,11 +3,9 @@ import { localPackageVersion } from "./version.mjs";
 
 export const ADAPTER_HEALTH_PATH = "/_ccdx/health";
 export const ADAPTER_STATUS_PATH = "/_ccdx/status";
-export const ADAPTER_PROTOCOL_VERSION = 2;
+export const ADAPTER_PROTOCOL_VERSION = 3;
 export const ADAPTER_VERSION = localPackageVersion();
-export const ADAPTER_CAPABILITIES = Object.freeze([
-  "pm_studio_split_origin_v1",
-]);
+export const ADAPTER_CAPABILITIES = Object.freeze([]);
 const ADAPTER_INSTANCE_ID = randomUUID();
 
 export function adapterHealthPayload() {

package/src/stream-errors.mjs

@@ -1,19 +1,16 @@
 import { writeOrDrain } from "./http-transport.mjs";
 import { markStreamFailure } from "./stream-performance.mjs";
 
-function streamErrorData(protocol, error, abort) {
+function streamErrorData(error, abort) {
   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 } };
-  }
   return { type: "error", code, message, param: null };
 }
 
-export async function endStreamWithError(res, protocol, error, abort) {
+export async function endStreamWithError(res, error, abort) {
   markStreamFailure();
   if (res.destroyed || res.writableEnded) return;
-  const data = streamErrorData(protocol, error, abort);
+  const data = streamErrorData(error, abort);
   await writeOrDrain(res, `event: error\ndata: ${JSON.stringify(data)}\n\n`).catch(() => false);
   if (!res.destroyed && !res.writableEnded) res.end();
 }

package/src/stream-performance.mjs

@@ -1,7 +1,7 @@
 import { performance } from "node:perf_hooks";
 import { currentRequestContext } from "./request-context.mjs";
 
-const PERFORMANCE_ROUTES = Object.freeze(["responses", "responses_compact", "messages"]);
+const PERFORMANCE_ROUTES = Object.freeze(["responses", "responses_compact"]);
 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,

package/src/usage.mjs

@@ -56,20 +56,6 @@ function normalizeResponsesUsage(usage) {
   return hasPositiveTokenValue(out) ? out : undefined;
 }
 
-function normalizeAnthropicUsage(usage) {
-  if (!usage || typeof usage !== "object") return undefined;
-  const out = compactObject({
-    input_tokens: positiveNumber(usage.input_tokens),
-    cache_read_input_tokens: positiveNumber(usage.cache_read_input_tokens),
-    cache_creation_input_tokens: positiveNumber(usage.cache_creation_input_tokens),
-    output_tokens: positiveNumber(usage.output_tokens),
-  });
-  if (out.input_tokens !== undefined || out.cache_read_input_tokens !== undefined || out.cache_creation_input_tokens !== undefined || out.output_tokens !== undefined) {
-    out.total_tokens = (out.input_tokens || 0) + (out.cache_read_input_tokens || 0) + (out.cache_creation_input_tokens || 0) + (out.output_tokens || 0);
-  }
-  return hasPositiveTokenValue(out) ? out : undefined;
-}
-
 function normalizeCopilotUsage(copilotUsage) {
   if (!copilotUsage || typeof copilotUsage !== "object") return undefined;
   const out = {};
@@ -112,19 +98,6 @@ export function buildResponsesUsageRecord({ surface = "responses", mode, model,
   });
 }
 
-export function buildAnthropicUsageRecord({ surface = "messages", mode, model, responseId, usage } = {}) {
-  const normalized = normalizeAnthropicUsage(usage);
-  if (!normalized) return null;
-  return compactObject({
-    ts: new Date().toISOString(),
-    surface,
-    mode,
-    model,
-    response_id: responseId,
-    usage: normalized,
-  });
-}
-
 function takePendingWrites(filePath, maxBytes) {
   const batch = [];
   let retained = 0;
@@ -188,10 +161,6 @@ export function recordResponsesUsage(args) {
   return recordUsage(buildResponsesUsageRecord(args));
 }
 
-export function recordAnthropicUsage(args) {
-  return recordUsage(buildAnthropicUsageRecord(args));
-}
-
 export async function flushUsageWritesForTests() {
   while (writeDrain || pendingWrites.length > 0) {
     if (writeDrain) await writeDrain;

package/src/anthropic-handler.mjs

@@ -1,195 +0,0 @@
-import {
-  anthropicToChat,
-  chatToAnthropic,
-  countTokens,
-  streamAnthropicFromLines,
-} from "./anthropic.mjs";
-import {
-  createRequestAbort,
-  logRequestFailure,
-  MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
-  MAX_UPSTREAM_ERROR_BODY_BYTES,
-  readJsonBody,
-  readBoundedResponseText,
-  sendJsonError,
-  sendUpstreamError,
-  writeOrDrain,
-} from "./http-transport.mjs";
-import { resolveAnthropicModel } from "./models.mjs";
-import { status } from "./status.mjs";
-import { webStreamLines } from "./stream.mjs";
-import { endStreamWithError } from "./stream-errors.mjs";
-import { requireUpstreamEventStream, withChatStreamUsage } from "./stream-contract.mjs";
-import { safeUpstreamResponseHeaders } from "./upstream-headers.mjs";
-import { recordAnthropicUsage } from "./usage.mjs";
-
-const PROMPT_TOO_LONG_MESSAGE = "prompt is too long: your prompt is too long. Please reduce the number of messages or use a model with a larger context window.";
-const DOWNSTREAM_CLOSED = Symbol("downstream-closed");
-
-function contextWindowErrorBody(text) {
-  let error;
-  try {
-    const parsed = JSON.parse(text);
-    error = parsed && typeof parsed === "object" ? parsed.error : null;
-  } catch {
-    error = { message: text };
-  }
-  if (!error || typeof error !== "object") return null;
-  const code = error.code;
-  const message = typeof error.message === "string" ? error.message.toLowerCase() : "";
-  const matches = code === "context_length_exceeded"
-    || code === "model_max_prompt_tokens_exceeded"
-    || message.includes("exceeds the context window of this model")
-    || message.includes("maximum context length is")
-    || message.includes("request body is too large for model context window");
-  if (!matches) return null;
-  return JSON.stringify({
-    type: "error",
-    error: { type: "invalid_request_error", message: PROMPT_TOO_LONG_MESSAGE },
-  });
-}
-
-function sendAnthropicUpstreamError(res, response, text) {
-  const rewritten = contextWindowErrorBody(text);
-  if (!rewritten) {
-    sendUpstreamError(res, response, text);
-    return;
-  }
-  const headers = new Headers(response.headers);
-  headers.set("content-type", "application/json");
-  sendUpstreamError(res, { status: response.status, headers }, rewritten);
-}
-
-export function createAnthropicCountTokensHandler(options) {
-  const { acquireRequest, requestBodyTimeoutMs, countTokensFn = countTokens } = options;
-
-  return async function handleAnthropicCountTokens(req, res) {
-    const abort = createRequestAbort(req, res);
-    let releaseRequest = () => {};
-    try {
-      releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
-      const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
-      abort.clearTimeout();
-      const result = await countTokensFn(parsed, { signal: abort.signal });
-      releaseRequest();
-      res.writeHead(200, { "Content-Type": "application/json" });
-      res.end(JSON.stringify(result));
-    } catch (error) {
-      sendJsonError(res, error, abort.reason === "request_body_timeout" ? 408 : 500);
-    } finally {
-      releaseRequest();
-      abort.cleanup();
-    }
-  };
-}
-
-export function createAnthropicMessagesHandler(options) {
-  const {
-    acquireRequest,
-    chatCompletionsFn,
-    environment,
-    modelOptions,
-    requestBodyTimeoutMs,
-    streamHandshakeTimeoutMs,
-    streamIdleTimeoutMs,
-    upstreamTimeoutMs,
-  } = options;
-
-  return async function handleAnthropicMessages(req, res) {
-    const abort = createRequestAbort(req, res);
-    let releaseRequest = () => {};
-    try {
-      releaseRequest = await acquireRequest(req, { signal: abort.signal });
-      abort.setTimeout(requestBodyTimeoutMs, "request_body_timeout");
-      const parsed = await readJsonBody(req, { admission: releaseRequest, signal: abort.signal });
-      abort.setTimeout(
-        parsed.stream ? streamHandshakeTimeoutMs : upstreamTimeoutMs,
-        parsed.stream ? "stream_handshake_timeout" : "upstream_timeout",
-      );
-      const { requestedModel, upstreamModel } = resolveAnthropicModel(parsed.model || "unknown", environment, modelOptions());
-      const modelNote = upstreamModel === requestedModel ? requestedModel : `${requestedModel} -> ${upstreamModel}`;
-      console.log(status("info", `messages model=${modelNote} stream=${!!parsed.stream}`));
-      const chatReq = anthropicToChat(parsed, { upstreamModel });
-      const forceRequestedModel = upstreamModel !== requestedModel;
-      if (parsed.stream) {
-        const upstream = await chatCompletionsFn(withChatStreamUsage(chatReq), { signal: abort.signal });
-        releaseRequest();
-        if (!upstream.ok) {
-          sendAnthropicUpstreamError(res, upstream, await readBoundedResponseText(upstream, {
-            maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
-            label: "Copilot Chat error body",
-          }));
-          return;
-        }
-        await requireUpstreamEventStream(upstream);
-        abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout");
-        res.writeHead(200, {
-          ...safeUpstreamResponseHeaders(upstream.headers, { contentType: "text/event-stream" }),
-          "Cache-Control": "no-cache",
-          Connection: "keep-alive",
-        });
-        let messageId;
-        let usage;
-        try {
-          await streamAnthropicFromLines(
-            webStreamLines(upstream, {
-              onChunk: () => abort.setTimeout(streamIdleTimeoutMs, "stream_idle_timeout"),
-            }),
-            async (event, data) => {
-              if (event === "message_start") messageId = data.message?.id;
-              if (event === "message_delta") usage = data.usage;
-              if (!await writeOrDrain(res, `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`)) {
-                throw DOWNSTREAM_CLOSED;
-              }
-            },
-            requestedModel,
-            { forceModel: forceRequestedModel },
-          );
-        } catch (error) {
-          if (error === DOWNSTREAM_CLOSED) return;
-          logRequestFailure("Messages", error, abort);
-          await endStreamWithError(res, "anthropic", error, abort);
-          return;
-        }
-        recordAnthropicUsage({ surface: "messages", mode: "stream", model: requestedModel, responseId: messageId, usage });
-        if (!res.writableEnded) res.end();
-      } else {
-        const upstream = await chatCompletionsFn({ ...chatReq, stream: false }, { signal: abort.signal });
-        releaseRequest();
-        const data = upstream.ok
-          ? await readBoundedResponseText(upstream, {
-            maxBytes: MAX_UPSTREAM_CHAT_SUCCESS_BODY_BYTES,
-            label: "Copilot Chat success body",
-            signal: abort.signal,
-          })
-          : await readBoundedResponseText(upstream, {
-            maxBytes: MAX_UPSTREAM_ERROR_BODY_BYTES,
-            label: "Copilot Chat error body",
-          });
-        if (!upstream.ok) {
-          sendAnthropicUpstreamError(res, upstream, data);
-          return;
-        }
-        const anthropicMessage = chatToAnthropic(JSON.parse(data), requestedModel, { forceModel: forceRequestedModel });
-        recordAnthropicUsage({
-          surface: "messages",
-          mode: "json",
-          model: anthropicMessage.model,
-          responseId: anthropicMessage.id,
-          usage: anthropicMessage.usage,
-        });
-        res.writeHead(200, safeUpstreamResponseHeaders(upstream.headers, {
-          contentType: "application/json",
-        }));
-        res.end(JSON.stringify(anthropicMessage));
-      }
-    } catch (error) {
-      logRequestFailure("Messages", error, abort);
-      sendJsonError(res, error, 502);
-    } finally {
-      releaseRequest();
-      abort.cleanup();
-    }
-  };
-}