@mytegroupinc/myte-core 0.0.37 → 0.0.38

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

@@ -0,0 +1,431 @@
+"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,
+};

package/mytecody-cli.js

@@ -12,6 +12,9 @@ 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;
@@ -249,6 +252,7 @@ function commonStatus(args, envPath) {
     gateway: {
       base_url: gatewayBase(args),
       inference_base_url: codyInferenceBase(args),
+      responses_transport: "async-job-bridge",
       network_required_for_coding: true,
     },
     instruction_pack: {
@@ -765,7 +769,7 @@ function writeCodexModelCatalog() {
   return catalogPath;
 }
 
-function writeCodexConfig(args = {}) {
+function writeCodexConfig(args = {}, providerBaseUrl = codyInferenceBase(args)) {
   fs.mkdirSync(codexHome(), { recursive: true });
   const catalogPath = writeCodexModelCatalog();
   const config = `model = ${tomlString(DEFAULT_MODEL_ALIAS)}
@@ -786,7 +790,7 @@ terminal_title = ["project"]
 
 [model_providers.myte_ai]
 name = "Myte AI"
-base_url = ${tomlString(codyInferenceBase(args))}
+base_url = ${tomlString(providerBaseUrl)}
 env_key = "MYTE_CODY_AUTH_TOKEN"
 wire_api = "responses"
 requires_openai_auth = false
@@ -826,14 +830,14 @@ function resolveCodexCommand() {
   return null;
 }
 
-function codexProviderArgs(args = {}) {
+function codexProviderArgs(args = {}, providerBaseUrl = codyInferenceBase(args)) {
   return [
     "-c",
     'model_provider="myte_ai"',
     "-c",
     'model_providers.myte_ai.name="Myte AI"',
     "-c",
-    `model_providers.myte_ai.base_url="${codyInferenceBase(args)}"`,
+    `model_providers.myte_ai.base_url="${providerBaseUrl}"`,
     "-c",
     'model_providers.myte_ai.env_key="MYTE_CODY_AUTH_TOKEN"',
     "-c",
@@ -863,8 +867,8 @@ function codexProviderArgs(args = {}) {
   ];
 }
 
-function codexLaunchArgs(rawArgs, args = {}) {
-  const providerArgs = codexProviderArgs(args);
+function codexLaunchArgs(rawArgs, args = {}, providerBaseUrl = codyInferenceBase(args)) {
+  const providerArgs = codexProviderArgs(args, providerBaseUrl);
   if (!rawArgs.length) return providerArgs;
   if (rawArgs[0] === "exec") return [...providerArgs, "exec", "--skip-git-repo-check", ...rawArgs.slice(1)];
   return [...providerArgs, ...rawArgs];
@@ -880,7 +884,6 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
   const progress = setupProgress(splash);
   splash.start("preparing trusted workspace");
   progress("preparing trusted workspace");
-  writeCodexConfig(args);
   try {
     const install = await ensureBrandedEngineInstalled(args, envPath, { progress });
     if (install.ok && install.installed) {
@@ -914,12 +917,27 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     console.error("Run `mytecody update` with access to the Myte release manifest.");
     return 1;
   }
-  const launchArgs = [...command.args, ...codexLaunchArgs(rawArgs, args)];
+  let bridge = null;
+  try {
+    progress("opening Myte inference bridge");
+    bridge = await startMyteCodyAsyncResponsesBridge({
+      gatewayRoot: gatewayRoot(args),
+      token,
+    });
+    writeCodexConfig(args, bridge.baseUrl);
+  } catch (error) {
+    await splash.stop();
+    console.error(`MyteCody inference bridge failed to start: ${error && error.message ? error.message : error}`);
+    return 1;
+  }
+
+  const launchArgs = [...command.args, ...codexLaunchArgs(rawArgs, args, bridge.baseUrl)];
   const env = {
     ...process.env,
     CODEX_HOME: codexHome(),
     MYTE_CODY_AUTH_TOKEN: token,
     MYTE_CODY_BRAND: "1",
+    MYTE_CODY_BRIDGE_BASE_URL: bridge.baseUrl,
   };
   progress("opening MyteCody workspace");
   await splash.stop();
@@ -933,9 +951,11 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     });
     child.on("error", (error) => {
       console.error(`Unable to launch MyteCody engine: ${error.message || error}`);
-      resolve(1);
+      bridge.close().finally(() => resolve(1));
+    });
+    child.on("close", (code) => {
+      bridge.close().finally(() => resolve(Number.isInteger(code) ? code : 1));
     });
-    child.on("close", (code) => resolve(Number.isInteger(code) ? code : 1));
   });
 }
 

package/package.json

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