@mytegroupinc/myte-core 0.0.36 → 0.0.38

package/README.md

@@ -31,6 +31,10 @@ This package exists so the public wrapper can stay small and versioned cleanly.
   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`.
+- `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.

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,14 +12,21 @@ 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;
+const DEFAULT_PACKAGE_LATEST_URL = "https://registry.npmjs.org/myte/latest";
 const DEFAULT_CHANNEL = "alpha";
 const DEFAULT_MODEL_ALIAS = "myte";
 const DEFAULT_CONTEXT_WINDOW = Number(process.env.MYTE_CODY_CONTEXT_WINDOW || 49152);
 const DEFAULT_AUTO_COMPACT_TOKENS = Number(process.env.MYTE_CODY_AUTO_COMPACT_TOKENS || 40960);
 const DEFAULT_TOOL_OUTPUT_TOKENS = Number(process.env.MYTE_CODY_TOOL_OUTPUT_TOKENS || 10000);
 const DEFAULT_AGENT_THREADS = Number(process.env.MYTE_CODY_AGENT_THREADS || 4);
+const CLIENT_BASE_INSTRUCTIONS =
+  "You are MyteCody, a coding agent running through the Myte coding gateway.";
 
 function findEnvPath(startDir) {
   let cur = startDir;
@@ -214,6 +221,10 @@ Usage:
   mytecody update [--json] [--manifest <url-or-file>]
   mytecody help
 
+Updates:
+  mytecody update              updates the signed MyteCody engine only
+  npm install -g myte@latest   updates this npm launcher and Myte API tools
+
 Network:
   The distributed MyteCody client uses the Myte AI gateway for coding
   inference. It can inspect local config without network, but coding requires
@@ -233,6 +244,7 @@ function commonStatus(args, envPath) {
     product: "MyteCody",
     command: "mytecody",
     package_version: PACKAGE_VERSION,
+    package: packageStatusBase(args),
     mode: "team-gateway",
     workspace: process.cwd(),
     env_file: envPath,
@@ -240,8 +252,19 @@ 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: {
+      owner: "myte-cody-gateway",
+      client_embedded: false,
+    },
+    runtime: {
+      context_window: DEFAULT_CONTEXT_WINDOW,
+      auto_compact_tokens: DEFAULT_AUTO_COMPACT_TOKENS,
+      tool_output_tokens: DEFAULT_TOOL_OUTPUT_TOKENS,
+      max_concurrent_agent_threads: DEFAULT_AGENT_THREADS,
+    },
     release: {
       channel: String(args.channel || process.env.MYTE_CODY_RELEASE_CHANNEL || DEFAULT_CHANNEL),
       manifest_url: manifestUrl(args),
@@ -255,6 +278,103 @@ function commonStatus(args, envPath) {
   };
 }
 
+function packageLatestUrl(args = {}) {
+  return String(
+    args["package-latest-url"] ||
+      process.env.MYTE_CODY_PACKAGE_LATEST_URL ||
+      process.env.MYTE_PACKAGE_LATEST_URL ||
+      DEFAULT_PACKAGE_LATEST_URL,
+  );
+}
+
+function packageUpdateCheckEnabled(args = {}) {
+  if (args["package-update-check"] === false) return false;
+  return process.env.MYTE_CODY_PACKAGE_UPDATE_CHECK !== "0";
+}
+
+function packageStatusBase(args = {}) {
+  return {
+    name: PACKAGE_NAME,
+    installed_version: PACKAGE_VERSION,
+    latest_version: null,
+    update_available: null,
+    check_status: "not-checked",
+    latest_url: packageLatestUrl(args),
+    update_command: `npm install -g ${PACKAGE_NAME}@latest`,
+    engine_update_command: "mytecody update",
+  };
+}
+
+function parseSemverish(version) {
+  const main = String(version || "")
+    .trim()
+    .replace(/^v/i, "")
+    .split(/[+-]/)[0];
+  const match = main.match(/^(\d+)(?:\.(\d+))?(?:\.(\d+))?/);
+  if (!match) return null;
+  return [match[1], match[2] || "0", match[3] || "0"].map((part) => Number(part));
+}
+
+function compareSemverish(left, right) {
+  const leftParts = parseSemverish(left);
+  const rightParts = parseSemverish(right);
+  if (!leftParts || !rightParts) return String(left || "").localeCompare(String(right || ""));
+  for (let i = 0; i < 3; i += 1) {
+    if (leftParts[i] > rightParts[i]) return 1;
+    if (leftParts[i] < rightParts[i]) return -1;
+  }
+  return 0;
+}
+
+function isVersionNewer(latest, installed = PACKAGE_VERSION) {
+  return compareSemverish(latest, installed) > 0;
+}
+
+function packageUpdateTimeoutMs() {
+  const value = Number(process.env.MYTE_CODY_PACKAGE_UPDATE_TIMEOUT_MS || 1500);
+  return Number.isFinite(value) && value > 0 ? value : 1500;
+}
+
+async function checkPackageUpdate(args = {}) {
+  const status = packageStatusBase(args);
+  if (!packageUpdateCheckEnabled(args)) {
+    return { ...status, check_status: "skipped" };
+  }
+  try {
+    const response = await fetchJson(status.latest_url, {
+      timeoutMs: packageUpdateTimeoutMs(),
+    });
+    if (!response.ok) {
+      return {
+        ...status,
+        check_status: "unavailable",
+        registry_status: response.status,
+      };
+    }
+    const latestVersion = response.body && response.body.version ? String(response.body.version) : "";
+    if (!latestVersion) {
+      return { ...status, check_status: "invalid-response" };
+    }
+    return {
+      ...status,
+      latest_version: latestVersion,
+      update_available: isVersionNewer(latestVersion, PACKAGE_VERSION),
+      check_status: "ok",
+    };
+  } catch (error) {
+    return {
+      ...status,
+      check_status: "unavailable",
+      error: error && error.message ? error.message : String(error),
+    };
+  }
+}
+
+function packageUpdateNotice(packageStatus) {
+  if (!packageStatus || packageStatus.update_available !== true) return "";
+  return `myte package update available: ${packageStatus.latest_version} (installed ${packageStatus.installed_version}). Run ${packageStatus.update_command}`;
+}
+
 function printJson(payload) {
   console.log(JSON.stringify(payload, null, 2));
 }
@@ -601,26 +721,13 @@ function pathForToml(value) {
 
 function writeCodexModelCatalog() {
   fs.mkdirSync(codexHome(), { recursive: true });
-  const baseInstructions = [
-    "You are MyteCody, a coding agent running in the Myte terminal harness.",
-    "",
-    "You and the user share one local workspace. Start in the current repository and operate there by default. Inspect outside the current repository only when explicitly asked.",
-    "",
-    "Your job is to understand the user's intent, inspect the relevant files, run local commands when useful, edit files with the available patch tool, run focused verification, and stop when the task is actually handled.",
-    "",
-    "For documentation, architecture, and repo-summary work, verify each material claim independently before presenting it as implemented fact. Separate current implementation from planned direction and unknowns. Treat planning docs as intent unless source code, config, command output, or logs prove the behavior exists.",
-    "",
-    "For edits, prefer apply_patch. If a patch fails, read the error, inspect the target file again, and retry with a corrected patch. Do not claim completion until after inspecting the resulting file or relevant diff.",
-    "",
-    "Keep responses concise and factual. Do not invent commands, flags, telemetry names, tool behavior, context-window defaults, retrieval behavior, or implemented features.",
-  ].join("\n");
   const catalog = {
     models: [
       {
         slug: DEFAULT_MODEL_ALIAS,
         display_name: "Myte",
         description: "Myte AI coding model.",
-        base_instructions: baseInstructions,
+        base_instructions: CLIENT_BASE_INSTRUCTIONS,
         default_reasoning_level: "medium",
         supported_reasoning_levels: [
           { effort: "low", description: "Fast local coding pass." },
@@ -662,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)}
@@ -683,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
@@ -723,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",
@@ -760,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];
@@ -777,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) {
@@ -796,6 +902,14 @@ async function runCodex(rawArgs, args = {}, envPath = null) {
     return 1;
   }
 
+  let packageNotice = "";
+  try {
+    progress("checking myte package version");
+    packageNotice = packageUpdateNotice(await checkPackageUpdate(args));
+  } catch {
+    packageNotice = "";
+  }
+
   const command = resolveCodexCommand();
   if (!command) {
     await splash.stop();
@@ -803,15 +917,31 @@ 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();
+  if (packageNotice) statusLine(packageNotice);
   return new Promise((resolve) => {
     const child = spawn(command.cmd, launchArgs, {
       cwd: process.cwd(),
@@ -821,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));
   });
 }
 
@@ -833,6 +965,7 @@ async function runDoctor(args, envPath) {
     ready_for_coding: false,
     ...commonStatus(args, envPath),
   };
+  payload.package = await checkPackageUpdate(args);
   if (args["probe-gateway"]) {
     payload.gateway.probe = await probeGateway(args);
   }
@@ -853,6 +986,17 @@ async function runDoctor(args, envPath) {
   if (payload.gateway.probe) {
     console.log(`gateway probe: ${payload.gateway.probe.ok ? "ok" : "failed"}`);
   }
+  console.log(`package:    ${payload.package.installed_version}`);
+  if (payload.package.check_status === "ok" && payload.package.update_available) {
+    console.log(`package update: ${payload.package.latest_version} available`);
+    console.log(`package command: ${payload.package.update_command}`);
+  } else if (payload.package.check_status === "ok") {
+    console.log("package update: current");
+  } else if (payload.package.check_status === "skipped") {
+    console.log("package update: skipped");
+  } else {
+    console.log(`package update: ${payload.package.check_status}`);
+  }
   console.log(`client:     ${payload.release.client_installed ? payload.release.client_version : "not installed"}`);
   console.log(`install:    ${payload.release.install_root}`);
   console.log("");
@@ -981,6 +1125,7 @@ async function runUpdate(args, envPath) {
     return 0;
   }
   console.log(dryRun ? "MYTE CODY update dry-run" : "MYTE CODY update");
+  console.log("scope: MyteCody engine only");
   console.log(`manifest: ${payload.manifest.source}`);
   console.log(`manifest read: ${payload.manifest.read_status}`);
   console.log(`platform: ${payload.release.platform}`);
@@ -996,6 +1141,7 @@ async function runUpdate(args, envPath) {
   if (payload.installed) {
     console.log(`installed: ${payload.installed.executable}`);
   }
+  console.log(`npm launcher/API tools: ${payload.package.update_command}`);
   return 0;
 }
 
@@ -1034,6 +1180,7 @@ if (require.main === module) {
 }
 
 module.exports = {
+  checkPackageUpdate,
   codexLaunchArgs,
   codexProviderArgs,
   codyInferenceBase,
@@ -1043,6 +1190,8 @@ module.exports = {
   ensureBrandedEngineInstalled,
   gatewayRoot,
   installedClientCommand,
+  isVersionNewer,
+  packageUpdateNotice,
   resolveCodexCommand,
   run,
   sha256Hex,

package/package.json

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