@moxt-ai/mobius 0.0.146 → 0.0.147

package/dist/index.js

@@ -32569,6 +32569,17 @@ var AgentProbeFailed = class extends UnavailableAgent {
     this.message = message;
   }
 };
+var UnsupportedAgentVersion = class extends UnavailableInstalledAgent {
+  code = "agent_version_unsupported";
+  message;
+  minimumSupportedVersion;
+  status = "unsupported_version";
+  constructor(specification, agent, minimumSupportedVersion) {
+    super(specification, agent);
+    this.minimumSupportedVersion = minimumSupportedVersion;
+    this.message = `Agent version ${agent.agentVersion} is below the minimum supported version ${minimumSupportedVersion}`;
+  }
+};
 var IntegrationProbeFailed = class extends UnavailableInstalledAgent {
   code;
   message;
@@ -32596,12 +32607,25 @@ var AuthenticationRequiredAgent = class extends UnavailableInstalledAgent {
     super(specification, agent);
   }
 };
+var AgentDiscoveryResult = class {
+  detectionMilliseconds;
+  discovery;
+  constructor(discovery, detectionMilliseconds) {
+    if (!Number.isFinite(detectionMilliseconds) || detectionMilliseconds < 0) {
+      throw new Error("The Agent detection duration is invalid");
+    }
+    this.detectionMilliseconds = Math.round(detectionMilliseconds * 1e3) / 1e3;
+    this.discovery = discovery;
+  }
+};
 var LocalAgentInventory = class {
   available;
   discoveries;
   installable;
+  results;
   unavailable;
-  constructor(discoveries) {
+  constructor(results) {
+    const discoveries = results.map((result) => result.discovery);
     const available = [];
     const unavailable = [];
     for (const discovery of discoveries) {
@@ -32620,8 +32644,17 @@ var LocalAgentInventory = class {
         (discovery) => discovery instanceof UnavailableInstalledAgent ? discovery.agent : new MissingAgentDefinition(discovery.specification.id, discovery.specification.label)
       )
     );
+    this.results = Object.freeze([...results]);
     this.unavailable = Object.freeze(unavailable);
   }
+  detectionMillisecondsFor = (discovery) => {
+    for (const result of this.results) {
+      if (result.discovery === discovery) {
+        return result.detectionMilliseconds;
+      }
+    }
+    throw new Error("The Agent discovery result is unavailable");
+  };
   readyAgents = () => this.available.map((discovery) => discovery.agent);
 };
 
@@ -36540,15 +36573,20 @@ async function discoverAgent(specification, context) {
       );
       continue;
     }
-    if (!supportedVersion) {
-      continue;
-    }
     const installedAgent = new AgentIntegrationDefinition(
       specification.id,
       specification.label,
       agent.identity.requestedPath,
       agentVersion
     );
+    if (!supportedVersion) {
+      lastFailure = new UnsupportedAgentVersion(
+        specification,
+        installedAgent,
+        specification.minimumSupportedAgentVersion
+      );
+      continue;
+    }
     if (adapters.length === 0 && !(specification instanceof InProcessAcpAgentDefinition2)) {
       return new MissingAdapter(specification, installedAgent);
     }
@@ -36642,10 +36680,15 @@ async function discoverAgent(specification, context) {
 // src/agent-catalog/discover-local-agents.ts
 async function discoverLocalAgentInventory(options) {
   const specifications = options.specifications ?? supportedLocalAgentSpecifications();
-  const discoveries = await Promise.all(
-    specifications.map(async (specification) => await discoverAgent(specification, options))
+  const monotonicTimeMilliseconds = options.monotonicTimeMilliseconds ?? (() => performance.now());
+  const results = await Promise.all(
+    specifications.map(async (specification) => {
+      const startedAt = monotonicTimeMilliseconds();
+      const discovery = await discoverAgent(specification, options);
+      return new AgentDiscoveryResult(discovery, monotonicTimeMilliseconds() - startedAt);
+    })
   );
-  return new LocalAgentInventory(discoveries);
+  return new LocalAgentInventory(results);
 }
 
 // src/storage/runtime-installation-store.ts