@mytegroupinc/myte-core 0.0.38 → 0.0.40

package/README.md

@@ -28,16 +28,17 @@ This package exists so the public wrapper can stay small and versioned cleanly.
 - Public package documentation is intentionally minimal. Internal rollout and design notes are not part of the npm package contract.
 - `mytecody` is a model-agnostic MyteCody team launcher. It supports `doctor`,
   `doctor --probe-gateway`, `update --dry-run`, and `update`. On first coding
-  run, it installs the branded MyteCody engine from the Myte release manifest
-  into a user-local Myte cache after signature/hash checks. Coding execution
-  requires that engine, a reachable Myte AI Cody gateway, and `MYTEAI_API_KEY`.
+  run, it installs the branded MyteCody engine and signed client assets from
+  the Myte release manifest into a user-local Myte cache after signature/hash
+  checks. Coding execution requires those assets, a reachable Myte AI Cody
+  gateway, and `MYTEAI_API_KEY`.
 - `mytecody doctor` reports both the signed MyteCody engine state and this npm
   package version. `mytecody update` updates the engine only. Use
   `npm install -g myte@latest` to update the launcher and the Myte API CLI
   commands shipped by npm.
-- The package does not bundle the large MyteCody engine binary. See
-  `THIRD_PARTY_NOTICES.md` and `TRADEMARKS.md` for Codex lineage and Myte brand
-  notices.
+- The package does not bundle the large MyteCody engine binary or the async
+  Responses bridge implementation. See `THIRD_PARTY_NOTICES.md` and
+  `TRADEMARKS.md` for Codex lineage and Myte brand notices.
 
 ## Agent Usage Contract
 

package/THIRD_PARTY_NOTICES.md

@@ -13,9 +13,9 @@ Source lineage tracked for this slice:
 - License: Apache-2.0
 - Upstream: https://github.com/openai/codex
 
-The MyteCody engine artifact is distributed separately from this npm package
-through a Myte release manifest. This package verifies the release artifact
-before installing it into the user's Myte-owned local cache.
+The MyteCody engine and signed client assets are distributed separately from
+this npm package through a Myte release manifest. This package verifies release
+artifacts before installing them into the user's Myte-owned local cache.
 
 Myte names, marks, logos, terminal branding, and product design are not part of
 the OpenAI Codex project and remain Myte-owned brand assets.

package/mytecody-cli.js

@@ -12,9 +12,6 @@ const {
   normalizeMyteAiBase,
 } = require("./lib/ai-gateway");
 const { createMyteSplash } = require("./lib/mytecody-splash");
-const {
-  startMyteCodyAsyncResponsesBridge,
-} = require("./lib/mytecody-async-responses-bridge");
 
 const PACKAGE_NAME = "myte";
 const PACKAGE_VERSION = require("./package.json").version;
@@ -154,13 +151,21 @@ function installRoot() {
   return path.join(os.homedir(), ".myte", "cody");
 }
 
+function currentInstallRoot() {
+  return path.join(installRoot(), "current");
+}
+
 function currentClientManifestPath() {
-  return path.join(installRoot(), "current", "manifest.json");
+  return path.join(currentInstallRoot(), "manifest.json");
 }
 
 function currentEnginePath() {
   const executable = process.platform === "win32" ? "mytecody-engine.exe" : "mytecody-engine";
-  return path.join(installRoot(), "current", "bin", executable);
+  return path.join(currentInstallRoot(), "bin", executable);
+}
+
+function currentBridgePath() {
+  return path.join(currentInstallRoot(), "lib", "mytecody-async-responses-bridge.js");
 }
 
 function codexHome() {
@@ -187,6 +192,100 @@ function installedClientCommand() {
   return { cmd: enginePath, args: [], source: "myte-installed-engine" };
 }
 
+function installedClientUsable() {
+  return Boolean(installedClientCommand() && fs.existsSync(currentBridgePath()) && readCurrentClientManifest());
+}
+
+function loadSignedBridge() {
+  const bridgePath = currentBridgePath();
+  if (!fs.existsSync(bridgePath)) {
+    throw new Error("signed MyteCody inference bridge asset is missing; run `mytecody update`.");
+  }
+  const bridge = require(bridgePath);
+  if (!bridge || typeof bridge.startMyteCodyAsyncResponsesBridge !== "function") {
+    throw new Error("signed MyteCody inference bridge asset is invalid.");
+  }
+  return bridge;
+}
+
+function releaseAssetsForPlatform(manifest, artifact) {
+  const assets = [];
+  const collect = (value, source) => {
+    if (!value) return;
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        if (item && typeof item === "object") {
+          assets.push({ ...item, source, index });
+        }
+      });
+      return;
+    }
+    if (typeof value === "object") {
+      Object.entries(value).forEach(([name, item], index) => {
+        if (item && typeof item === "object") {
+          assets.push({ name: item.name || name, ...item, source, index });
+        }
+      });
+    }
+  };
+
+  collect(manifest && manifest.client_assets, "manifest.client_assets");
+  collect(artifact && artifact.assets, "artifact.assets");
+
+  return assets
+    .map((asset) => ({
+      ...asset,
+      install_path: asset.install_path || asset.path || "",
+    }))
+    .filter((asset) => asset && asset.url && asset.sha256 && asset.install_path);
+}
+
+function assertSafeReleaseAssetInstallPath(installPath) {
+  const raw = String(installPath || "").replace(/\\/g, "/").trim();
+  if (!raw) throw new Error("release asset install_path is required");
+  if (path.isAbsolute(raw) || /^[A-Za-z]:/.test(raw)) {
+    throw new Error(`release asset install_path must be relative: ${installPath}`);
+  }
+  const parts = raw.split("/").filter(Boolean);
+  if (!parts.length || parts.includes("..")) {
+    throw new Error(`release asset install_path is unsafe: ${installPath}`);
+  }
+  return path.join(currentInstallRoot(), ...parts);
+}
+
+function currentReleaseAssetRecordByPath(current) {
+  const map = new Map();
+  for (const asset of Array.isArray(current && current.assets) ? current.assets : []) {
+    if (asset && asset.install_path) {
+      map.set(String(asset.install_path).replace(/\\/g, "/"), asset);
+    }
+  }
+  return map;
+}
+
+function installedReleaseAssetsMatchManifest(manifest, artifact) {
+  const assets = releaseAssetsForPlatform(manifest, artifact);
+  if (!assets.length) return true;
+  const current = readCurrentClientManifest();
+  const currentAssets = currentReleaseAssetRecordByPath(current);
+
+  for (const asset of assets) {
+    const installPath = String(asset.install_path || "").replace(/\\/g, "/");
+    const currentAsset = currentAssets.get(installPath);
+    if (!currentAsset) return false;
+    if (String(currentAsset.sha256 || "").toLowerCase() !== String(asset.sha256 || "").toLowerCase()) {
+      return false;
+    }
+    const targetPath = assertSafeReleaseAssetInstallPath(asset.install_path);
+    if (!fs.existsSync(targetPath)) return false;
+    const installedSha = sha256Hex(fs.readFileSync(targetPath));
+    if (installedSha.toLowerCase() !== String(asset.installed_sha256 || asset.sha256).toLowerCase()) {
+      return false;
+    }
+  }
+  return true;
+}
+
 function installedClientMatchesManifest(manifest, artifact) {
   const current = readCurrentClientManifest();
   if (!current || !installedClientCommand()) return false;
@@ -207,6 +306,8 @@ function installedClientMatchesManifest(manifest, artifact) {
     }
   }
 
+  if (!installedReleaseAssetsMatchManifest(manifest, artifact)) return false;
+
   return true;
 }
 
@@ -271,8 +372,10 @@ function commonStatus(args, envPath) {
       platform: platformKey(),
       install_root: installRoot(),
       engine_path: currentEnginePath(),
+      bridge_path: currentBridgePath(),
       client_manifest: currentClientManifestPath(),
       client_installed: Boolean(current && installedClientCommand()),
+      bridge_installed: fs.existsSync(currentBridgePath()),
       client_version: current && current.version ? current.version : null,
     },
   };
@@ -517,11 +620,11 @@ function localPathFromArtifactUrl(urlValue) {
   return null;
 }
 
-async function readArtifactBytes(artifact, { progress } = {}) {
+async function readArtifactBytes(artifact, { progress, label = "MyteCody engine" } = {}) {
   const urlValue = artifact && artifact.url ? String(artifact.url) : "";
   const localPath = localPathFromArtifactUrl(urlValue);
   if (localPath) {
-    if (progress) progress("reading local MyteCody engine artifact");
+    if (progress) progress(`reading local ${label} artifact`);
     return fs.readFileSync(localPath);
   }
   const headers = {};
@@ -529,7 +632,7 @@ async function readArtifactBytes(artifact, { progress } = {}) {
   if (token) headers.Authorization = `Bearer ${token}`;
   if (progress) {
     const expectedSize = Number(artifact && artifact.size_bytes ? artifact.size_bytes : 0);
-    progress(`downloading MyteCody engine (${formatBytes(expectedSize)})`);
+    progress(`downloading ${label} (${formatBytes(expectedSize)})`);
   }
   const response = await fetch(urlValue, { method: "GET", headers });
   if (!response.ok) {
@@ -538,7 +641,7 @@ async function readArtifactBytes(artifact, { progress } = {}) {
   }
   if (!response.body || typeof response.body.getReader !== "function") {
     const bytes = Buffer.from(await response.arrayBuffer());
-    if (progress) progress(`downloaded MyteCody engine (${formatBytes(bytes.length)})`);
+    if (progress) progress(`downloaded ${label} (${formatBytes(bytes.length)})`);
     return bytes;
   }
 
@@ -556,13 +659,13 @@ async function readArtifactBytes(artifact, { progress } = {}) {
     if (progress && total > 0) {
       const pct = Math.min(100, Math.floor((received / total) * 100));
       if (pct >= lastPct + 10 || pct === 100) {
-        progress(`downloading MyteCody engine ${pct}% (${formatBytes(received)} / ${formatBytes(total)})`);
+        progress(`downloading ${label} ${pct}% (${formatBytes(received)} / ${formatBytes(total)})`);
         lastPct = pct;
       }
     }
   }
   const bytes = Buffer.concat(chunks);
-  if (progress) progress(`downloaded MyteCody engine (${formatBytes(bytes.length)})`);
+  if (progress) progress(`downloaded ${label} (${formatBytes(bytes.length)})`);
   return bytes;
 }
 
@@ -621,6 +724,34 @@ function installArtifactBytes(bytes, manifest, artifact) {
   return installedManifest;
 }
 
+async function installReleaseAssets(manifest, artifact, { progress } = {}) {
+  const assets = releaseAssetsForPlatform(manifest, artifact);
+  const installed = [];
+  for (const asset of assets) {
+    const name = String(asset.name || path.basename(String(asset.install_path || "")) || "client asset");
+    const bytes = await readArtifactBytes(asset, { progress, label: `MyteCody ${name}` });
+    const digest = sha256Hex(bytes);
+    if (digest.toLowerCase() !== String(asset.sha256 || "").toLowerCase()) {
+      throw new Error(`Release asset SHA-256 mismatch for ${name}: expected ${asset.sha256}, got ${digest}`);
+    }
+    const installBytes = artifactBytesForInstall(bytes, asset);
+    const targetPath = assertSafeReleaseAssetInstallPath(asset.install_path);
+    fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+    fs.writeFileSync(targetPath, installBytes);
+    installed.push({
+      name,
+      install_path: String(asset.install_path || "").replace(/\\/g, "/"),
+      url: asset.url,
+      sha256: asset.sha256,
+      format: artifactFormat(asset),
+      size_bytes: bytes.length,
+      installed_sha256: sha256Hex(installBytes),
+      installed_size_bytes: installBytes.length,
+    });
+  }
+  return installed;
+}
+
 async function fetchJson(url, { headers = {}, timeoutMs = 8000 } = {}) {
   const controller = typeof AbortController !== "undefined" ? new AbortController() : undefined;
   const timeoutId =
@@ -920,7 +1051,8 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
   let bridge = null;
   try {
     progress("opening Myte inference bridge");
-    bridge = await startMyteCodyAsyncResponsesBridge({
+    const signedBridge = loadSignedBridge();
+    bridge = await signedBridge.startMyteCodyAsyncResponsesBridge({
       gatewayRoot: gatewayRoot(args),
       token,
     });
@@ -969,7 +1101,8 @@ async function runDoctor(args, envPath) {
   if (args["probe-gateway"]) {
     payload.gateway.probe = await probeGateway(args);
   }
-  payload.ready_for_coding = payload.auth.present && payload.release.client_installed;
+  payload.ready_for_coding =
+    payload.auth.present && payload.release.client_installed && payload.release.bridge_installed;
   if (payload.gateway.probe) {
     payload.ready_for_coding = Boolean(payload.ready_for_coding && payload.gateway.probe.ok);
   }
@@ -998,6 +1131,7 @@ async function runDoctor(args, envPath) {
     console.log(`package update: ${payload.package.check_status}`);
   }
   console.log(`client:     ${payload.release.client_installed ? payload.release.client_version : "not installed"}`);
+  console.log(`bridge:     ${payload.release.bridge_installed ? "installed" : "not installed"}`);
   console.log(`install:    ${payload.release.install_root}`);
   console.log("");
   console.log("Coding requires the Myte AI gateway and a Myte AI key.");
@@ -1015,6 +1149,7 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
   const artifact = manifest ? artifactForPlatform(manifest) : null;
   const signature = manifest ? signatureAccepted(manifest, args) : { ok: false, signature: { status: "not-checked", verified: false } };
   const artifactMetadata = manifest ? validateArtifactMetadata(artifact) : { status: "not-checked", ok: false };
+  const releaseAssets = manifest ? releaseAssetsForPlatform(manifest, artifact) : [];
   const payload = {
     ok: true,
     dry_run: isDryRun,
@@ -1028,6 +1163,13 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
       trusted_unsigned: Boolean(signature.trusted_unsigned),
     },
     artifact: artifactMetadata,
+    release_assets: releaseAssets.map((asset) => ({
+      name: asset.name || null,
+      install_path: asset.install_path,
+      url: asset.url || null,
+      format: asset.format || null,
+      sha256_present: Boolean(asset.sha256),
+    })),
   };
 
   if (!isDryRun) {
@@ -1046,6 +1188,11 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
       throw new Error(`Artifact SHA-256 mismatch: expected ${artifact.sha256}, got ${digest}`);
     }
     const installed = installArtifactBytes(bytes, manifest, artifact);
+    const installedAssets = await installReleaseAssets(manifest, artifact, { progress });
+    if (installedAssets.length) {
+      installed.assets = installedAssets;
+      fs.writeFileSync(currentClientManifestPath(), JSON.stringify(installed, null, 2), "utf8");
+    }
     payload.installed = {
       ok: true,
       version: installed.version,
@@ -1055,6 +1202,7 @@ async function buildUpdatePayload(args, envPath, { dryRun = false, progress = nu
       installed_sha256: installed.artifact.installed_sha256,
       installed_size_bytes: installed.artifact.installed_size_bytes,
       format: installed.artifact.format,
+      assets: installedAssets,
     };
     payload.release = {
       ...payload.release,
@@ -1082,9 +1230,31 @@ async function ensureBrandedEngineInstalled(args = {}, envPath = null, { progres
   delete updateArgs.json;
 
   const source = manifestUrl(updateArgs);
-  const manifestResult = await readManifest(source, { fetchManifest: true, progress });
+  let manifestResult;
+  try {
+    manifestResult = await readManifest(source, { fetchManifest: true, progress });
+  } catch (error) {
+    if (isUrl(source) && installedClientUsable()) {
+      return {
+        ok: true,
+        installed: false,
+        reason: "cached-engine-manifest-unavailable",
+        manifest_status: "fetch-failed",
+        error: error && error.message ? error.message : String(error),
+      };
+    }
+    throw error;
+  }
   const manifest = manifestResult.manifest;
   if (!manifest) {
+    if (isUrl(source) && installedClientUsable()) {
+      return {
+        ok: true,
+        installed: false,
+        reason: "cached-engine-manifest-unavailable",
+        manifest_status: manifestResult.status,
+      };
+    }
     return { ok: false, installed: false, reason: "manifest-unavailable", manifest_status: manifestResult.status };
   }
   const signature = signatureAccepted(manifest, updateArgs);
@@ -1185,6 +1355,7 @@ module.exports = {
   codexProviderArgs,
   codyInferenceBase,
   codyGatewayUrl,
+  currentBridgePath,
   currentClientManifestPath,
   currentEnginePath,
   ensureBrandedEngineInstalled,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mytegroupinc/myte-core",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "description": "Myte CLI core implementation.",
   "type": "commonjs",
   "main": "cli.js",

package/lib/mytecody-async-responses-bridge.js

@@ -1,431 +0,0 @@
-"use strict";
-
-const http = require("node:http");
-const crypto = require("node:crypto");
-
-const HOST = "127.0.0.1";
-const PATCH_TOOL_NAME = "apply_patch";
-
-function sendJson(res, status, payload, headers = {}) {
-  res.writeHead(status, {
-    "content-type": "application/json",
-    "cache-control": "no-store",
-    ...headers,
-  });
-  res.end(JSON.stringify(payload));
-}
-
-function readJsonBody(req) {
-  return new Promise((resolve, reject) => {
-    const chunks = [];
-    req.on("data", (chunk) => chunks.push(Buffer.from(chunk)));
-    req.on("error", reject);
-    req.on("end", () => {
-      const text = Buffer.concat(chunks).toString("utf8");
-      if (!text.trim()) return resolve(null);
-      try {
-        resolve(JSON.parse(text));
-      } catch (error) {
-        reject(new Error(`invalid JSON body: ${error.message || error}`));
-      }
-    });
-  });
-}
-
-function stableJson(value) {
-  if (Array.isArray(value)) return `[${value.map(stableJson).join(",")}]`;
-  if (value && typeof value === "object") {
-    return `{${Object.keys(value)
-      .sort()
-      .map((key) => `${JSON.stringify(key)}:${stableJson(value[key])}`)
-      .join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-
-function requestHash(value) {
-  return crypto.createHash("sha256").update(stableJson(value)).digest("hex");
-}
-
-function parseJsonMaybe(value) {
-  if (value && typeof value === "object") return value;
-  if (typeof value !== "string") return null;
-  try {
-    return JSON.parse(value);
-  } catch {
-    return null;
-  }
-}
-
-function extractPatchArgument(argumentsValue) {
-  const parsed = parseJsonMaybe(argumentsValue);
-  if (parsed && typeof parsed.patch === "string") return parsed.patch;
-  if (parsed && typeof parsed.input === "string") return parsed.input;
-  if (
-    typeof argumentsValue === "string" &&
-    argumentsValue.includes("*** Begin Patch") &&
-    argumentsValue.includes("*** End Patch")
-  ) {
-    return argumentsValue;
-  }
-  return "";
-}
-
-function normalizeOutputItem(item) {
-  if (!item || typeof item !== "object") return null;
-  const normalized = { ...item };
-  if (
-    normalized.type === "function_call" &&
-    normalized.arguments &&
-    typeof normalized.arguments !== "string"
-  ) {
-    normalized.arguments = JSON.stringify(normalized.arguments);
-  }
-  return normalized;
-}
-
-function functionCallToCustomPatchCall(item) {
-  if (!item || item.type !== "function_call" || item.name !== PATCH_TOOL_NAME) return null;
-  const patch = extractPatchArgument(item.arguments);
-  if (!patch) return null;
-  const callId = item.call_id || item.id || `call_myte_patch_${Date.now()}`;
-  return {
-    id: item.id || callId,
-    type: "custom_tool_call",
-    status: item.status || "completed",
-    call_id: callId,
-    name: PATCH_TOOL_NAME,
-    input: patch,
-  };
-}
-
-function adaptOutputItemForCodex(rawItem) {
-  const item = normalizeOutputItem(rawItem);
-  if (!item) return null;
-  return functionCallToCustomPatchCall(item) || item;
-}
-
-function adaptResponsePayloadForCodex(payload) {
-  if (!payload || typeof payload !== "object") return payload;
-  const output = Array.isArray(payload.output)
-    ? payload.output.map(adaptOutputItemForCodex).filter(Boolean)
-    : payload.output;
-  return {
-    ...payload,
-    model: "myte",
-    output,
-  };
-}
-
-function sse(res, event) {
-  res.write(`event: ${event.type}\n`);
-  res.write(`data: ${JSON.stringify(event)}\n\n`);
-}
-
-function chunkText(text, size = 4096) {
-  const value = String(text || "");
-  const chunks = [];
-  for (let index = 0; index < value.length; index += size) {
-    chunks.push(value.slice(index, index + size));
-  }
-  return chunks.length ? chunks : [""];
-}
-
-function emitOutputItem(res, item, outputIndex) {
-  if (item && item.type === "custom_tool_call" && item.name === PATCH_TOOL_NAME) {
-    const itemId = item.id || item.call_id || `call_myte_patch_${Date.now()}`;
-    const callId = item.call_id || itemId;
-    const input = item.input || "";
-    sse(res, {
-      type: "response.output_item.added",
-      output_index: outputIndex,
-      item: {
-        ...item,
-        id: itemId,
-        call_id: callId,
-        input: "",
-        status: "in_progress",
-      },
-    });
-    for (const delta of chunkText(input)) {
-      sse(res, {
-        type: "response.custom_tool_call_input.delta",
-        output_index: outputIndex,
-        item_id: itemId,
-        call_id: callId,
-        delta,
-      });
-    }
-    sse(res, {
-      type: "response.custom_tool_call_input.done",
-      output_index: outputIndex,
-      item_id: itemId,
-      call_id: callId,
-      input,
-    });
-    sse(res, {
-      type: "response.output_item.done",
-      output_index: outputIndex,
-      item: {
-        ...item,
-        id: itemId,
-        call_id: callId,
-        input,
-        status: "completed",
-      },
-    });
-    return;
-  }
-
-  sse(res, {
-    type: "response.output_item.done",
-    output_index: outputIndex,
-    item,
-  });
-}
-
-function retryAfterMs(headers, fallbackMs) {
-  const headerValue =
-    headers && typeof headers.get === "function" ? Number(headers.get("retry-after")) : 0;
-  if (Number.isFinite(headerValue) && headerValue > 0) {
-    return Math.max(250, Math.min(15000, headerValue * 1000));
-  }
-  return fallbackMs;
-}
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function fetchJson(url, options = {}) {
-  const response = await fetch(url, options);
-  const text = await response.text();
-  let body = {};
-  if (text.trim()) {
-    try {
-      body = JSON.parse(text);
-    } catch {
-      body = { raw_text: text };
-    }
-  }
-  return { response, body, text };
-}
-
-function absoluteGatewayUrl(root, pathOrUrl) {
-  const value = String(pathOrUrl || "");
-  if (/^https?:\/\//i.test(value)) return value;
-  const base = String(root || "").replace(/\/+$/, "");
-  const tail = value.startsWith("/") ? value : `/${value}`;
-  return `${base}${tail}`;
-}
-
-function resultPayloadFromJobResult(body) {
-  if (body && typeof body === "object" && body.object === "response") return body;
-  if (body && typeof body === "object" && body.payload && typeof body.payload === "object") {
-    return body.payload;
-  }
-  return body;
-}
-
-async function submitAndDrainResponseJob(body, options) {
-  const gatewayRoot = String(options.gatewayRoot || "").replace(/\/+$/, "");
-  const token = String(options.token || "").trim();
-  if (!gatewayRoot) throw new Error("missing Myte Cody gateway root");
-  if (!token) throw new Error("missing MYTEAI_API_KEY");
-
-  const bridgeRequestId = `codybridge_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
-  const requestBody = {
-    ...body,
-    request_id: body.request_id || bridgeRequestId,
-    stream: false,
-  };
-  const timeoutMs = Number(options.timeoutMs || process.env.MYTE_CODY_ASYNC_TIMEOUT_MS || 900000);
-  const startedAt = Date.now();
-  const submitUrl = `${gatewayRoot}/cody/v1/jobs/responses`;
-  const authHeaders = {
-    authorization: `Bearer ${token}`,
-    accept: "application/json",
-  };
-  const idempotencyKey = `mytecody-${bridgeRequestId}-${requestHash(requestBody).slice(0, 16)}`;
-  const submitted = await fetchJson(submitUrl, {
-    method: "POST",
-    headers: {
-      ...authHeaders,
-      "content-type": "application/json",
-      "idempotency-key": idempotencyKey,
-    },
-    body: JSON.stringify(requestBody),
-  });
-  if (!submitted.response.ok && submitted.response.status !== 202) {
-    throw new Error(
-      `MyteCody async submit failed (${submitted.response.status}): ${submitted.text.slice(0, 500)}`,
-    );
-  }
-
-  const submitBody = submitted.body || {};
-  const jobId = submitBody.job_id || submitBody.id;
-  const poll = submitBody.poll || {};
-  let resultUrl = absoluteGatewayUrl(
-    gatewayRoot,
-    poll.result_url || (jobId ? `/cody/v1/jobs/${jobId}/result` : ""),
-  );
-  const statusUrl = absoluteGatewayUrl(
-    gatewayRoot,
-    poll.status_url || (jobId ? `/cody/v1/jobs/${jobId}` : ""),
-  );
-  if (!jobId || !resultUrl) {
-    return resultPayloadFromJobResult(submitBody);
-  }
-
-  let waitMs = retryAfterMs(submitted.response.headers, 500);
-  while (Date.now() - startedAt < timeoutMs) {
-    const separator = resultUrl.includes("?") ? "&" : "?";
-    const result = await fetchJson(`${resultUrl}${separator}consume=1`, {
-      method: "GET",
-      headers: authHeaders,
-    });
-    if (result.response.status === 200) return resultPayloadFromJobResult(result.body);
-    if (result.response.status !== 202) {
-      throw new Error(
-        `MyteCody async result failed (${result.response.status}): ${result.text.slice(0, 500)}`,
-      );
-    }
-    const status = result.body || {};
-    if (status.status === "failed" || status.status === "cancelled" || status.status === "expired") {
-      throw new Error(`MyteCody async job ${jobId} ended with status ${status.status}`);
-    }
-    resultUrl = absoluteGatewayUrl(gatewayRoot, status.poll?.result_url || resultUrl);
-    waitMs = retryAfterMs(result.response.headers, waitMs);
-    if (typeof options.onPoll === "function") {
-      options.onPoll({
-        job_id: jobId,
-        status: status.status || "queued",
-        status_url: statusUrl,
-        result_url: resultUrl,
-      });
-    }
-    await sleep(waitMs);
-  }
-  throw new Error(`MyteCody async job ${jobId} timed out after ${Math.round(timeoutMs / 1000)}s`);
-}
-
-async function handleResponses(req, res, body, options) {
-  const responseId = `resp_myte_${Date.now()}_${crypto.randomBytes(4).toString("hex")}`;
-  const wantsStream = body && body.stream !== false;
-  if (!wantsStream) {
-    const payload = adaptResponsePayloadForCodex(await submitAndDrainResponseJob(body, options));
-    return sendJson(res, 200, payload);
-  }
-
-  res.writeHead(200, {
-    "content-type": "text/event-stream; charset=utf-8",
-    "cache-control": "no-cache, no-transform",
-    connection: "keep-alive",
-    "x-myte-cody-async-bridge": "1",
-  });
-  sse(res, {
-    type: "response.created",
-    response: { id: responseId, object: "response", status: "in_progress" },
-  });
-
-  const keepalive = setInterval(() => {
-    res.write(": keepalive\n\n");
-  }, 10000);
-  let closed = false;
-  res.on("close", () => {
-    closed = true;
-    clearInterval(keepalive);
-  });
-
-  try {
-    const payload = adaptResponsePayloadForCodex(await submitAndDrainResponseJob(body, options));
-    if (closed) return;
-    const output = Array.isArray(payload && payload.output) ? payload.output : [];
-    output.forEach((item, index) => emitOutputItem(res, item, index));
-    sse(res, {
-      type: "response.completed",
-      response: {
-        ...payload,
-        id: responseId,
-        object: payload && payload.object ? payload.object : "response",
-        status: "completed",
-      },
-    });
-    clearInterval(keepalive);
-    res.end();
-  } catch (error) {
-    clearInterval(keepalive);
-    if (!closed) {
-      sse(res, {
-        type: "response.failed",
-        response: {
-          id: responseId,
-          error: {
-            code: "myte_cody_async_bridge_failed",
-            message: error && error.message ? error.message : String(error),
-          },
-        },
-      });
-      res.end();
-    }
-  }
-}
-
-async function handle(req, res, options) {
-  try {
-    const url = new URL(req.url, `http://${HOST}`);
-    if (req.method === "GET" && (url.pathname === "/health" || url.pathname === "/v1/health")) {
-      return sendJson(res, 200, { ok: true, service: "myte-cody-async-responses-bridge" });
-    }
-    if (req.method === "GET" && url.pathname === "/v1/models") {
-      return sendJson(res, 200, {
-        object: "list",
-        data: [{ id: "myte", object: "model", owned_by: "myte" }],
-      });
-    }
-    if (req.method === "POST" && (url.pathname === "/v1/responses" || url.pathname === "/responses")) {
-      const body = await readJsonBody(req);
-      if (!body || typeof body !== "object") {
-        return sendJson(res, 400, { error: { message: "JSON object body required" } });
-      }
-      return handleResponses(req, res, body, options);
-    }
-    return sendJson(res, 404, { error: { message: "not found" } });
-  } catch (error) {
-    return sendJson(res, 500, {
-      error: { message: error && error.message ? error.message : String(error) },
-    });
-  }
-}
-
-async function startMyteCodyAsyncResponsesBridge(options = {}) {
-  const server = http.createServer((req, res) => {
-    handle(req, res, options);
-  });
-  await new Promise((resolve, reject) => {
-    server.once("error", reject);
-    server.listen(0, HOST, resolve);
-  });
-  const address = server.address();
-  const port = address && typeof address === "object" ? address.port : 0;
-  let closed = false;
-  return {
-    host: HOST,
-    port,
-    baseUrl: `http://${HOST}:${port}/v1`,
-    close: () => {
-      if (closed) return Promise.resolve();
-      closed = true;
-      return new Promise((resolve) => {
-        server.close(() => resolve());
-      });
-    },
-  };
-}
-
-module.exports = {
-  adaptResponsePayloadForCodex,
-  extractPatchArgument,
-  startMyteCodyAsyncResponsesBridge,
-  submitAndDrainResponseJob,
-};