agent-relay 9.2.1 → 9.2.2

package/dist/index.cjs

@@ -192,7 +192,6 @@ __export(index_exports, {
   buildModelSwitchCommand: () => buildModelSwitchCommand,
   checkForUpdates: () => checkForUpdates,
   checkForUpdatesInBackground: () => checkForUpdatesInBackground,
-  clearBinaryCache: () => clearBinaryCache,
   commandExists: () => commandExists,
   connectionLog: () => connectionLog,
   createAgentHandle: () => createAgentHandle,
@@ -208,24 +207,19 @@ __export(index_exports, {
   createWorkspaceFacade: () => createWorkspaceFacade,
   defineHarness: () => defineHarness,
   findGitRoot: () => findGitRoot,
-  findRelayPtyBinary: () => findRelayPtyBinary,
   formatAgentHandle: () => formatAgentHandle,
   generateAgentName: () => generateAgentName,
   generateErrorId: () => generateErrorId,
   generateRequestId: () => generateRequestId,
   generateUniqueAgentName: () => generateUniqueAgentName,
   getBaseCli: () => getBaseCli,
-  getCachedRelayPtyPath: () => getCachedRelayPtyPath,
   getCompiledPatterns: () => getCompiledPatterns,
   getGitRemoteUrl: () => getGitRemoteUrl,
-  getLastSearchPaths: () => getLastSearchPaths,
   getModelCommandConfig: () => getModelCommandConfig,
   getPatternMetrics: () => getPatternMetrics,
   getRepoFullName: () => getRepoFullName,
   getRepoFullNameFromPath: () => getRepoFullNameFromPath,
-  getSupportedPlatforms: () => getSupportedPlatforms,
   handleResponse: () => handleResponse2,
-  hasRelayPtyBinary: () => hasRelayPtyBinary,
   isEscapedFenceEndFast: () => isEscapedFenceEndFast,
   isInstructionalTextFast: () => isInstructionalTextFast,
   isInvalidAgentTokenError: () => isInvalidAgentTokenError,
@@ -233,7 +227,6 @@ __export(index_exports, {
   isMatchingResponse: () => isMatchingResponse,
   isModelSwitchSupported: () => isModelSwitchSupported,
   isPlaceholderTargetFast: () => isPlaceholderTargetFast,
-  isPlatformSupported: () => isPlatformSupported,
   isSpawnOrReleaseCommandFast: () => isSpawnOrReleaseCommandFast,
   isValidAgentName: () => isValidAgentName,
   logAndTraceError: () => logAndTraceError,
@@ -283,7 +276,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // ../sdk/node_modules/@relaycast/sdk/dist/version.js
-var SDK_VERSION = "5.0.11";
+var SDK_VERSION = "5.1.0";
 
 // ../sdk/node_modules/zod/v4/classic/external.js
 var external_exports = {};
@@ -1051,10 +1044,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path5) {
-  if (!path5)
+function getElementAtPath(obj, path4) {
+  if (!path4)
     return obj;
-  return path5.reduce((acc, key) => acc?.[key], obj);
+  return path4.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -1463,11 +1456,11 @@ function explicitlyAborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path5, issues) {
+function prefixIssues(path4, issues) {
   return issues.map((iss) => {
     var _a3;
     (_a3 = iss).path ?? (_a3.path = []);
-    iss.path.unshift(path5);
+    iss.path.unshift(path4);
     return iss;
   });
 }
@@ -1614,16 +1607,16 @@ function flattenError(error51, mapper = (issue2) => issue2.message) {
 }
 function formatError(error51, mapper = (issue2) => issue2.message) {
   const fieldErrors = { _errors: [] };
-  const processError = (error52, path5 = []) => {
+  const processError = (error52, path4 = []) => {
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           fieldErrors._errors.push(mapper(issue2));
         } else {
@@ -1650,17 +1643,17 @@ function formatError(error51, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error51, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error52, path5 = []) => {
+  const processError = (error52, path4 = []) => {
     var _a3, _b;
     for (const issue2 of error52.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
-        issue2.errors.map((issues) => processError({ issues }, [...path5, ...issue2.path]));
+        issue2.errors.map((issues) => processError({ issues }, [...path4, ...issue2.path]));
       } else if (issue2.code === "invalid_key") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else if (issue2.code === "invalid_element") {
-        processError({ issues: issue2.issues }, [...path5, ...issue2.path]);
+        processError({ issues: issue2.issues }, [...path4, ...issue2.path]);
       } else {
-        const fullpath = [...path5, ...issue2.path];
+        const fullpath = [...path4, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -1692,8 +1685,8 @@ function treeifyError(error51, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path5) {
+  const path4 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path4) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -14385,13 +14378,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path5 = ref.slice(1).split("/").filter(Boolean);
-  if (path5.length === 0) {
+  const path4 = ref.slice(1).split("/").filter(Boolean);
+  if (path4.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path5[0] === defsKey) {
-    const key = path5[1];
+  if (path4[0] === defsKey) {
+    const key = path4[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -17516,8 +17509,8 @@ var HttpClient = class _HttpClient {
       ...this._agentRelayDistinctId ? { agentRelayDistinctId: this._agentRelayDistinctId } : {}
     }));
   }
-  async request(method, path5, body, query, options) {
-    const url2 = new URL(path5, this._baseUrl);
+  async request(method, path4, body, query, options) {
+    const url2 = new URL(path4, this._baseUrl);
     if (query) {
       for (const [k, v] of Object.entries(query)) {
         if (v !== void 0)
@@ -17588,20 +17581,20 @@ var HttpClient = class _HttpClient {
       return camelizeKeys(parsedData);
     }
   }
-  get(path5, query, options) {
-    return this.request("GET", path5, void 0, query, options);
+  get(path4, query, options) {
+    return this.request("GET", path4, void 0, query, options);
   }
-  post(path5, body, options) {
-    return this.request("POST", path5, body, void 0, options);
+  post(path4, body, options) {
+    return this.request("POST", path4, body, void 0, options);
   }
-  patch(path5, body, options) {
-    return this.request("PATCH", path5, body, void 0, options);
+  patch(path4, body, options) {
+    return this.request("PATCH", path4, body, void 0, options);
   }
-  put(path5, body, options) {
-    return this.request("PUT", path5, body, void 0, options);
+  put(path4, body, options) {
+    return this.request("PUT", path4, body, void 0, options);
   }
-  async delete(path5, options) {
-    await this.request("DELETE", path5, void 0, void 0, options);
+  async delete(path4, options) {
+    await this.request("DELETE", path4, void 0, void 0, options);
   }
 };
 
@@ -18200,72 +18193,72 @@ function validateJsonSchemaLite(value, schema) {
   validateAgainstSchema(value, schema, "$", state);
   return { valid: state.issues.length === 0, issues: state.issues };
 }
-function validateAgainstSchema(value, schema, path5, state) {
+function validateAgainstSchema(value, schema, path4, state) {
   if (schema === true) {
     return;
   }
   if (schema === false) {
-    addIssue(state, path5, "value is not allowed", "never", describeValue(value));
+    addIssue(state, path4, "value is not allowed", "never", describeValue(value));
     return;
   }
   if (!isSchemaObject(schema)) {
-    addIssue(state, path5, "schema must be a boolean or object", "schema", describeValue(schema));
+    addIssue(state, path4, "schema must be a boolean or object", "schema", describeValue(schema));
     return;
   }
-  validateCombinators(value, schema, path5, state);
+  validateCombinators(value, schema, path4, state);
   if (schema.const !== void 0 && !jsonEqual(value, schema.const)) {
-    addIssue(state, path5, `expected const ${JSON.stringify(schema.const)}`, JSON.stringify(schema.const), describeValue(value));
+    addIssue(state, path4, `expected const ${JSON.stringify(schema.const)}`, JSON.stringify(schema.const), describeValue(value));
   }
   if (schema.enum && !schema.enum.some((candidate) => jsonEqual(value, candidate))) {
-    addIssue(state, path5, `expected one of ${schema.enum.map((candidate) => JSON.stringify(candidate)).join(", ")}`);
+    addIssue(state, path4, `expected one of ${schema.enum.map((candidate) => JSON.stringify(candidate)).join(", ")}`);
   }
   const types = getExpectedTypes(schema);
   if (types.length > 0 && !types.some((type) => matchesType(value, type))) {
-    addIssue(state, path5, `expected ${types.join(" or ")}`, types.join(" or "), describeValue(value));
+    addIssue(state, path4, `expected ${types.join(" or ")}`, types.join(" or "), describeValue(value));
     return;
   }
   if (shouldValidateObject(value, schema)) {
-    validateObject(value, schema, path5, state);
+    validateObject(value, schema, path4, state);
   }
   if (shouldValidateArray(value, schema)) {
-    validateArray(value, schema, path5, state);
+    validateArray(value, schema, path4, state);
   }
   if (typeof value === "string") {
-    validateString(value, schema, path5, state);
+    validateString(value, schema, path4, state);
   }
   if (typeof value === "number") {
-    validateNumber(value, schema, path5, state);
+    validateNumber(value, schema, path4, state);
   }
 }
-function validateCombinators(value, schema, path5, state) {
+function validateCombinators(value, schema, path4, state) {
   if (schema.allOf) {
     for (const child of schema.allOf) {
-      validateAgainstSchema(value, child, path5, state);
+      validateAgainstSchema(value, child, path4, state);
     }
   }
   if (schema.anyOf) {
     const matched = schema.anyOf.some((child) => validateJsonSchemaLite(value, child).valid);
     if (!matched) {
-      addIssue(state, path5, "expected value to match at least one anyOf schema");
+      addIssue(state, path4, "expected value to match at least one anyOf schema");
     }
   }
   if (schema.oneOf) {
     const matches = schema.oneOf.filter((child) => validateJsonSchemaLite(value, child).valid).length;
     if (matches !== 1) {
-      addIssue(state, path5, `expected value to match exactly one oneOf schema, matched ${matches}`);
+      addIssue(state, path4, `expected value to match exactly one oneOf schema, matched ${matches}`);
     }
   }
 }
-function validateObject(value, schema, path5, state) {
+function validateObject(value, schema, path4, state) {
   for (const key of schema.required ?? []) {
     if (!Object.prototype.hasOwnProperty.call(value, key)) {
-      addIssue(state, appendPath(path5, key), "required property is missing");
+      addIssue(state, appendPath(path4, key), "required property is missing");
     }
   }
   const properties = schema.properties ?? {};
   for (const [key, childSchema] of Object.entries(properties)) {
     if (Object.prototype.hasOwnProperty.call(value, key)) {
-      validateAgainstSchema(value[key], childSchema, appendPath(path5, key), state);
+      validateAgainstSchema(value[key], childSchema, appendPath(path4, key), state);
     }
   }
   const additional = schema.additionalProperties;
@@ -18277,48 +18270,48 @@ function validateObject(value, schema, path5, state) {
       continue;
     }
     if (additional === false) {
-      addIssue(state, appendPath(path5, key), "additional property is not allowed");
+      addIssue(state, appendPath(path4, key), "additional property is not allowed");
     } else {
-      validateAgainstSchema(value[key], additional, appendPath(path5, key), state);
+      validateAgainstSchema(value[key], additional, appendPath(path4, key), state);
     }
   }
 }
-function validateArray(value, schema, path5, state) {
+function validateArray(value, schema, path4, state) {
   if (schema.minItems !== void 0 && value.length < schema.minItems) {
-    addIssue(state, path5, `expected at least ${schema.minItems} items`);
+    addIssue(state, path4, `expected at least ${schema.minItems} items`);
   }
   if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
-    addIssue(state, path5, `expected at most ${schema.maxItems} items`);
+    addIssue(state, path4, `expected at most ${schema.maxItems} items`);
   }
   if (schema.items !== void 0) {
     value.forEach((item, index) => {
-      validateAgainstSchema(item, schema.items, `${path5}[${index}]`, state);
+      validateAgainstSchema(item, schema.items, `${path4}[${index}]`, state);
     });
   }
 }
-function validateString(value, schema, path5, state) {
+function validateString(value, schema, path4, state) {
   if (schema.minLength !== void 0 && value.length < schema.minLength) {
-    addIssue(state, path5, `expected length >= ${schema.minLength}`);
+    addIssue(state, path4, `expected length >= ${schema.minLength}`);
   }
   if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
-    addIssue(state, path5, `expected length <= ${schema.maxLength}`);
+    addIssue(state, path4, `expected length <= ${schema.maxLength}`);
   }
   if (schema.pattern !== void 0) {
     try {
       if (!new RegExp(schema.pattern).test(value)) {
-        addIssue(state, path5, `expected string to match /${schema.pattern}/`);
+        addIssue(state, path4, `expected string to match /${schema.pattern}/`);
       }
     } catch {
-      addIssue(state, path5, `invalid pattern /${schema.pattern}/`);
+      addIssue(state, path4, `invalid pattern /${schema.pattern}/`);
     }
   }
 }
-function validateNumber(value, schema, path5, state) {
+function validateNumber(value, schema, path4, state) {
   if (schema.minimum !== void 0 && value < schema.minimum) {
-    addIssue(state, path5, `expected value >= ${schema.minimum}`);
+    addIssue(state, path4, `expected value >= ${schema.minimum}`);
   }
   if (schema.maximum !== void 0 && value > schema.maximum) {
-    addIssue(state, path5, `expected value <= ${schema.maximum}`);
+    addIssue(state, path4, `expected value <= ${schema.maximum}`);
   }
 }
 function getExpectedTypes(schema) {
@@ -18367,12 +18360,12 @@ function isPlainObject3(value) {
 function isSchemaObject(value) {
   return isPlainObject3(value);
 }
-function appendPath(path5, key) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path5}.${key}` : `${path5}[${JSON.stringify(key)}]`;
+function appendPath(path4, key) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? `${path4}.${key}` : `${path4}[${JSON.stringify(key)}]`;
 }
-function addIssue(state, path5, message, expected, received) {
+function addIssue(state, path4, message, expected, received) {
   state.issues.push({
-    path: path5,
+    path: path4,
     message,
     ...expected !== void 0 ? { expected } : {},
     ...received !== void 0 ? { received } : {}
@@ -18702,11 +18695,11 @@ function zodIssues(error51) {
     message: issue2.message
   }));
 }
-function formatZodPath(path5) {
-  if (path5.length === 0)
+function formatZodPath(path4) {
+  if (path4.length === 0)
     return "$";
   let result = "$";
-  for (const part of path5) {
+  for (const part of path4) {
     result = typeof part === "number" ? `${result}[${part}]` : `${result}.${part}`;
   }
   return result;
@@ -22490,186 +22483,6 @@ function validateModelForCli(cli, model) {
   return { valid: true, normalizedModel };
 }
 
-// ../utils/dist/relay-pty-path.js
-var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path3 = __toESM(require("node:path"), 1);
-var SUPPORTED_PLATFORMS = {
-  darwin: {
-    arm64: "relay-pty-darwin-arm64",
-    x64: "relay-pty-darwin-x64"
-  },
-  linux: {
-    arm64: "relay-pty-linux-arm64",
-    x64: "relay-pty-linux-x64"
-  }
-};
-function getPlatformBinaryName() {
-  const platform = import_node_os2.default.platform();
-  const arch = import_node_os2.default.arch();
-  return SUPPORTED_PLATFORMS[platform]?.[arch] ?? null;
-}
-function isPlatformSupported() {
-  const platform = import_node_os2.default.platform();
-  const arch = import_node_os2.default.arch();
-  return SUPPORTED_PLATFORMS[platform]?.[arch] !== void 0;
-}
-function getSupportedPlatforms() {
-  const platforms = [];
-  for (const [os3, archs] of Object.entries(SUPPORTED_PLATFORMS)) {
-    for (const arch of Object.keys(archs)) {
-      platforms.push(`${os3}-${arch}`);
-    }
-  }
-  return platforms.join(", ");
-}
-var cachedBinaryPath;
-var cacheChecked = false;
-var lastSearchPaths = [];
-function getLastSearchPaths() {
-  return [...lastSearchPaths];
-}
-function findRelayPtyBinary(callerDirname) {
-  const envOverride = process.env.RELAY_PTY_BINARY;
-  if (envOverride && isExecutable(envOverride) && isPlatformCompatibleBinary(envOverride)) {
-    lastSearchPaths = [envOverride];
-    return envOverride;
-  }
-  const platformBinary = getPlatformBinaryName();
-  const normalizedCaller = callerDirname.replace(/\\/g, "/");
-  const packageRoots = [];
-  const scopedMatch = normalizedCaller.match(/^(.+?\/node_modules)\/@agent-relay\//);
-  const directMatch = normalizedCaller.match(/^(.+?\/node_modules\/agent-relay)/);
-  if (scopedMatch) {
-    packageRoots.push(import_node_path3.default.join(scopedMatch[1], "agent-relay"));
-  }
-  if (directMatch) {
-    packageRoots.push(directMatch[1]);
-  }
-  const home = process.env.HOME || process.env.USERPROFILE || "";
-  if (home) {
-    const npxCacheBase = import_node_path3.default.join(home, ".npm", "_npx");
-    if (import_node_fs4.default.existsSync(npxCacheBase)) {
-      try {
-        const entries = import_node_fs4.default.readdirSync(npxCacheBase);
-        for (const entry of entries) {
-          const npxPackage = import_node_path3.default.join(npxCacheBase, entry, "node_modules", "agent-relay");
-          if (import_node_fs4.default.existsSync(npxPackage)) {
-            packageRoots.push(npxPackage);
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  packageRoots.push(import_node_path3.default.join(process.cwd(), "node_modules", "agent-relay"));
-  if (home) {
-    packageRoots.push(import_node_path3.default.join(home, ".nvm", "versions", "node", process.version, "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path3.default.join(home, ".volta", "tools", "image", "packages", "agent-relay", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path3.default.join(home, ".fnm", "node-versions", process.version, "installation", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path3.default.join(home, "n", "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path3.default.join(home, ".asdf", "installs", "nodejs", process.version.replace("v", ""), "lib", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path3.default.join(home, ".local", "share", "pnpm", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path3.default.join(home, ".config", "yarn", "global", "node_modules", "agent-relay"));
-    packageRoots.push(import_node_path3.default.join(home, ".yarn", "global", "node_modules", "agent-relay"));
-  }
-  const bashInstallerDir = process.env.AGENT_RELAY_INSTALL_DIR ? import_node_path3.default.join(process.env.AGENT_RELAY_INSTALL_DIR, "bin") : home ? import_node_path3.default.join(home, ".agentworkforce/relay", "bin") : null;
-  const bashInstallerBinDir = process.env.AGENT_RELAY_BIN_DIR || (home ? import_node_path3.default.join(home, ".local", "bin") : null);
-  const nodePrefix = import_node_path3.default.resolve(import_node_path3.default.dirname(process.execPath), "..");
-  packageRoots.push(import_node_path3.default.join(nodePrefix, "lib", "node_modules", "agent-relay"));
-  packageRoots.push("/usr/local/lib/node_modules/agent-relay");
-  packageRoots.push("/opt/homebrew/lib/node_modules/agent-relay");
-  packageRoots.push("/usr/lib/node_modules/agent-relay");
-  const candidates = [];
-  for (const root of packageRoots) {
-    if (platformBinary) {
-      candidates.push(import_node_path3.default.join(root, "bin", platformBinary));
-    }
-    candidates.push(import_node_path3.default.join(root, "bin", "relay-pty"));
-  }
-  if (bashInstallerDir) {
-    if (platformBinary) {
-      candidates.push(import_node_path3.default.join(bashInstallerDir, platformBinary));
-    }
-    candidates.push(import_node_path3.default.join(bashInstallerDir, "relay-pty"));
-  }
-  if (bashInstallerBinDir) {
-    if (platformBinary) {
-      candidates.push(import_node_path3.default.join(bashInstallerBinDir, platformBinary));
-    }
-    candidates.push(import_node_path3.default.join(bashInstallerBinDir, "relay-pty"));
-  }
-  candidates.push("/app/bin/relay-pty");
-  candidates.push("/usr/local/bin/relay-pty");
-  candidates.push("/usr/bin/relay-pty");
-  lastSearchPaths = candidates;
-  for (const candidate of candidates) {
-    if (isExecutable(candidate) && isPlatformCompatibleBinary(candidate)) {
-      return candidate;
-    }
-  }
-  return null;
-}
-function isExecutable(filePath) {
-  try {
-    import_node_fs4.default.accessSync(filePath, import_node_fs4.default.constants.X_OK);
-    return true;
-  } catch {
-    return false;
-  }
-}
-function isPlatformCompatibleBinary(filePath) {
-  let fd;
-  try {
-    fd = import_node_fs4.default.openSync(filePath, "r");
-    const header = Buffer.alloc(4);
-    const bytesRead = import_node_fs4.default.readSync(fd, header, 0, 4, 0);
-    if (bytesRead < 4) {
-      return false;
-    }
-    const magic = header.readUInt32BE(0);
-    const platform = import_node_os2.default.platform();
-    if (platform === "darwin") {
-      return isMachOBinary(magic);
-    }
-    if (platform === "linux") {
-      return magic === 2135247942;
-    }
-    return true;
-  } catch {
-    return true;
-  } finally {
-    if (fd !== void 0) {
-      try {
-        import_node_fs4.default.closeSync(fd);
-      } catch {
-      }
-    }
-  }
-}
-function isMachOBinary(magic) {
-  return magic === 3489328638 || // MH_CIGAM_64 — 64-bit, byte-swapped (arm64/x64 LE files read as BE)
-  magic === 4277009103 || // MH_MAGIC_64 — 64-bit, native byte order
-  magic === 3472551422 || // MH_CIGAM    — 32-bit, byte-swapped
-  magic === 4277009102 || // MH_MAGIC    — 32-bit, native byte order
-  magic === 3405691582 || // FAT_MAGIC   — universal/fat binary
-  magic === 3199925962;
-}
-function hasRelayPtyBinary(callerDirname) {
-  if (!cacheChecked) {
-    cachedBinaryPath = findRelayPtyBinary(callerDirname);
-    cacheChecked = true;
-  }
-  return cachedBinaryPath !== null;
-}
-function getCachedRelayPtyPath() {
-  return cachedBinaryPath;
-}
-function clearBinaryCache() {
-  cachedBinaryPath = void 0;
-  cacheChecked = false;
-}
-
 // ../utils/dist/client-helpers.js
 var import_node_net = require("node:net");
 var import_node_crypto2 = require("node:crypto");
@@ -22836,7 +22649,6 @@ function generateRequestId(prefix = "") {
   buildModelSwitchCommand,
   checkForUpdates,
   checkForUpdatesInBackground,
-  clearBinaryCache,
   commandExists,
   connectionLog,
   createAgentHandle,
@@ -22852,24 +22664,19 @@ function generateRequestId(prefix = "") {
   createWorkspaceFacade,
   defineHarness,
   findGitRoot,
-  findRelayPtyBinary,
   formatAgentHandle,
   generateAgentName,
   generateErrorId,
   generateRequestId,
   generateUniqueAgentName,
   getBaseCli,
-  getCachedRelayPtyPath,
   getCompiledPatterns,
   getGitRemoteUrl,
-  getLastSearchPaths,
   getModelCommandConfig,
   getPatternMetrics,
   getRepoFullName,
   getRepoFullNameFromPath,
-  getSupportedPlatforms,
   handleResponse,
-  hasRelayPtyBinary,
   isEscapedFenceEndFast,
   isInstructionalTextFast,
   isInvalidAgentTokenError,
@@ -22877,7 +22684,6 @@ function generateRequestId(prefix = "") {
   isMatchingResponse,
   isModelSwitchSupported,
   isPlaceholderTargetFast,
-  isPlatformSupported,
   isSpawnOrReleaseCommandFast,
   isValidAgentName,
   logAndTraceError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-relay",
-  "version": "9.2.1",
+  "version": "9.2.2",
   "description": "Real-time agent-to-agent communication system",
   "type": "module",
   "main": "dist/index.cjs",
@@ -43,12 +43,12 @@
     "pack:validate": "npm pack --dry-run"
   },
   "dependencies": {
-    "@agent-relay/cloud": "9.2.1",
-    "@agent-relay/config": "9.2.1",
-    "@agent-relay/fleet": "9.2.1",
-    "@agent-relay/harness-driver": "9.2.1",
-    "@agent-relay/sdk": "9.2.1",
-    "@agent-relay/utils": "9.2.1",
+    "@agent-relay/cloud": "9.2.2",
+    "@agent-relay/config": "9.2.2",
+    "@agent-relay/fleet": "9.2.2",
+    "@agent-relay/harness-driver": "9.2.2",
+    "@agent-relay/sdk": "9.2.2",
+    "@agent-relay/utils": "9.2.2",
     "@modelcontextprotocol/sdk": "^1.0.0",
     "@relaycast/sdk": "^5.0.5",
     "@relayfile/client": "^0.10.19",
@@ -61,6 +61,9 @@
     "ws": "^8.18.3",
     "zod": "^3.23.8"
   },
+  "optionalDependencies": {
+    "ai-hist-native": "^0.4.1"
+  },
   "devDependencies": {
     "esbuild": "^0.27.2"
   },